@botpress/cli 0.9.6 → 0.11.0

package/dist/linter/rulesets/integration.ruleset.test.js

@@ -0,0 +1,825 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_integration = require("./integration.ruleset");
+var import_spectral_core = require("@stoplight/spectral-core");
+var import_spectral_parsers = require("@stoplight/spectral-parsers");
+const describeRule = (ruleName, fn) => import_vitest.describe.concurrent(ruleName, () => {
+  const spectral = new import_spectral_core.Spectral();
+  spectral.setRuleset({ rules: { [ruleName]: import_integration.INTEGRATION_RULESET.rules[ruleName] } });
+  const lintFn = (definition) => spectral.run(new import_spectral_core.Document(JSON.stringify(definition), import_spectral_parsers.Json));
+  fn(lintFn);
+});
+const EMPTY_STRING = "";
+const TRUTHY_STRING = "truthy";
+const ACTION_NAME = "actionName";
+const EVENT_NAME = "eventName";
+const CONFIG_NAME = "configName";
+const PARAM_NAME = "paramName";
+const TAG_NAME = "tagName";
+const CHANNEL_NAME = "channelName";
+const STATE_NAME = "stateName";
+const MESSAGE_TYPE = "text";
+const ZUI = "x-zui";
+const LEGACY_ZUI = "ui";
+describeRule("integration-title-must-be-present", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = {};
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = { title: EMPTY_STRING };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["title"]);
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = { title: TRUTHY_STRING };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("integration-description-must-be-present", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = {};
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = { description: EMPTY_STRING };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["description"]);
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = { description: TRUTHY_STRING };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("integration-must-have-an-icon", (lint) => {
+  (0, import_vitest.test)("missing icon should trigger", async () => {
+    const definition = {};
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.message).toContain("icon");
+  });
+  (0, import_vitest.test)("empty icon should trigger", async () => {
+    const definition = { icon: EMPTY_STRING };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["icon"]);
+  });
+  (0, import_vitest.test)("valid icon should not trigger", async () => {
+    const definition = { icon: TRUTHY_STRING };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("integration-must-have-a-readme-file", (lint) => {
+  (0, import_vitest.test)("missing readme should trigger", async () => {
+    const definition = {};
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.message).toContain("readme");
+  });
+  (0, import_vitest.test)("empty readme should trigger", async () => {
+    const definition = { readme: EMPTY_STRING };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["readme"]);
+  });
+  (0, import_vitest.test)("valid readme should not trigger", async () => {
+    const definition = { readme: TRUTHY_STRING };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("actions-should-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = { actions: { [ACTION_NAME]: {} } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["actions", ACTION_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = { actions: { [ACTION_NAME]: { title: EMPTY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["actions", ACTION_NAME, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = { actions: { [ACTION_NAME]: { title: TRUTHY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("actions-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = { actions: { [ACTION_NAME]: {} } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["actions", ACTION_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = { actions: { [ACTION_NAME]: { description: EMPTY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["actions", ACTION_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = { actions: { [ACTION_NAME]: { description: TRUTHY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("action-inputparams-should-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = {
+      actions: { [ACTION_NAME]: { input: { schema: { properties: { [PARAM_NAME]: { [ZUI]: {} } } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["actions", ACTION_NAME, "input", "schema", "properties", PARAM_NAME, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: EMPTY_STRING } } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual([
+      "actions",
+      ACTION_NAME,
+      "input",
+      "schema",
+      "properties",
+      PARAM_NAME,
+      ZUI,
+      "title"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: TRUTHY_STRING } } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("action-inputparams-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = {
+      actions: { [ACTION_NAME]: { input: { schema: { properties: { [PARAM_NAME]: {} } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["actions", ACTION_NAME, "input", "schema", "properties", PARAM_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { schema: { properties: { [PARAM_NAME]: { description: EMPTY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual([
+      "actions",
+      ACTION_NAME,
+      "input",
+      "schema",
+      "properties",
+      PARAM_NAME,
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { schema: { properties: { [PARAM_NAME]: { description: TRUTHY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("action-outputparams-should-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = {
+      actions: { [ACTION_NAME]: { output: { schema: { properties: { [PARAM_NAME]: { [ZUI]: {} } } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["actions", ACTION_NAME, "output", "schema", "properties", PARAM_NAME, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { output: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: EMPTY_STRING } } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual([
+      "actions",
+      ACTION_NAME,
+      "output",
+      "schema",
+      "properties",
+      PARAM_NAME,
+      ZUI,
+      "title"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { output: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: TRUTHY_STRING } } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("action-outputparams-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = {
+      actions: { [ACTION_NAME]: { output: { schema: { properties: { [PARAM_NAME]: {} } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["actions", ACTION_NAME, "output", "schema", "properties", PARAM_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { output: { schema: { properties: { [PARAM_NAME]: { description: EMPTY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual([
+      "actions",
+      ACTION_NAME,
+      "output",
+      "schema",
+      "properties",
+      PARAM_NAME,
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { output: { schema: { properties: { [PARAM_NAME]: { description: TRUTHY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("event-outputparams-should-have-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = {
+      events: { [EVENT_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: {} } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["events", EVENT_NAME, "schema", "properties", PARAM_NAME, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: EMPTY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["events", EVENT_NAME, "schema", "properties", PARAM_NAME, ZUI, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: TRUTHY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("event-outputparams-must-have-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = {
+      events: { [EVENT_NAME]: { schema: { properties: { [PARAM_NAME]: {} } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["events", EVENT_NAME, "schema", "properties", PARAM_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: { schema: { properties: { [PARAM_NAME]: { description: EMPTY_STRING } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["events", EVENT_NAME, "schema", "properties", PARAM_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: { schema: { properties: { [PARAM_NAME]: { description: TRUTHY_STRING } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("events-must-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = { events: { [EVENT_NAME]: {} } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["events", EVENT_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = { events: { [EVENT_NAME]: { title: EMPTY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["events", EVENT_NAME, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = { events: { [EVENT_NAME]: { title: TRUTHY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("events-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = { events: { [EVENT_NAME]: {} } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["events", EVENT_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = { events: { [EVENT_NAME]: { description: EMPTY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["events", EVENT_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = { events: { [EVENT_NAME]: { description: TRUTHY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("configuration-fields-must-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = { configuration: { schema: { properties: { [PARAM_NAME]: { [ZUI]: {} } } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configuration", "schema", "properties", PARAM_NAME, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      configuration: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: EMPTY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configuration", "schema", "properties", PARAM_NAME, ZUI, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      configuration: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: TRUTHY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("multiple-configurations-must-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: {} }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configurations", CONFIG_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: { title: EMPTY_STRING } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configurations", CONFIG_NAME, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: { title: TRUTHY_STRING } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("multiple-configurations-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: {} }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configurations", CONFIG_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: { description: EMPTY_STRING } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configurations", CONFIG_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: { description: TRUTHY_STRING } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("multipes-configurations-fields-must-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: {} } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configurations", CONFIG_NAME, "schema", "properties", PARAM_NAME, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: EMPTY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configurations", CONFIG_NAME, "schema", "properties", PARAM_NAME, ZUI, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: TRUTHY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("multipes-configurations-fields-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: { schema: { properties: { [PARAM_NAME]: {} } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configurations", CONFIG_NAME, "schema", "properties", PARAM_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: { schema: { properties: { [PARAM_NAME]: { description: EMPTY_STRING } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configurations", CONFIG_NAME, "schema", "properties", PARAM_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: { schema: { properties: { [PARAM_NAME]: { description: TRUTHY_STRING } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("user-tags-should-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = { user: { tags: { [TAG_NAME]: {} } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["user", "tags", TAG_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = { user: { tags: { [TAG_NAME]: { title: EMPTY_STRING } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["user", "tags", TAG_NAME, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = { user: { tags: { [TAG_NAME]: { title: TRUTHY_STRING } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("user-tags-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = { user: { tags: { [TAG_NAME]: {} } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["user", "tags", TAG_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = { user: { tags: { [TAG_NAME]: { description: EMPTY_STRING } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["user", "tags", TAG_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = { user: { tags: { [TAG_NAME]: { description: TRUTHY_STRING } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("channels-should-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: {} } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: { title: EMPTY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: { title: TRUTHY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("channels-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: {} } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: { description: EMPTY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: { description: TRUTHY_STRING } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("channels-conversation-tags-should-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: { conversation: { tags: { [TAG_NAME]: {} } } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "conversation", "tags", TAG_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      channels: { [CHANNEL_NAME]: { conversation: { tags: { [TAG_NAME]: { title: EMPTY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "conversation", "tags", TAG_NAME, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      channels: { [CHANNEL_NAME]: { conversation: { tags: { [TAG_NAME]: { title: TRUTHY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("channels-conversation-tags-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: { conversation: { tags: { [TAG_NAME]: {} } } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "conversation", "tags", TAG_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      channels: { [CHANNEL_NAME]: { conversation: { tags: { [TAG_NAME]: { description: EMPTY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "conversation", "tags", TAG_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      channels: { [CHANNEL_NAME]: { conversation: { tags: { [TAG_NAME]: { description: TRUTHY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("channels-message-tags-should-have-a-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: { message: { tags: { [TAG_NAME]: {} } } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "message", "tags", TAG_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      channels: { [CHANNEL_NAME]: { message: { tags: { [TAG_NAME]: { title: EMPTY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "message", "tags", TAG_NAME, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      channels: { [CHANNEL_NAME]: { message: { tags: { [TAG_NAME]: { title: TRUTHY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("channels-message-tags-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = { channels: { [CHANNEL_NAME]: { message: { tags: { [TAG_NAME]: {} } } } } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "message", "tags", TAG_NAME]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      channels: { [CHANNEL_NAME]: { message: { tags: { [TAG_NAME]: { description: EMPTY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["channels", CHANNEL_NAME, "message", "tags", TAG_NAME, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      channels: { [CHANNEL_NAME]: { message: { tags: { [TAG_NAME]: { description: TRUTHY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("legacy-zui-title-should-be-removed", (lint) => {
+  (0, import_vitest.test)("legacy zui title should trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { [LEGACY_ZUI]: { [PARAM_NAME]: { title: TRUTHY_STRING } }, schema: {} } }
+      },
+      configuration: {
+        [LEGACY_ZUI]: { [PARAM_NAME]: { title: TRUTHY_STRING } },
+        schema: {}
+      },
+      events: { [EVENT_NAME]: { [LEGACY_ZUI]: { [PARAM_NAME]: { title: TRUTHY_STRING } }, schema: {} } },
+      channels: {
+        [CHANNEL_NAME]: {
+          messages: { [MESSAGE_TYPE]: { [LEGACY_ZUI]: { [PARAM_NAME]: { title: TRUTHY_STRING } }, schema: {} } }
+        }
+      },
+      states: { [STATE_NAME]: { [LEGACY_ZUI]: { [PARAM_NAME]: { title: TRUTHY_STRING } }, schema: {} } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(5);
+    (0, import_vitest.expect)(results[0]?.message).toContain(".title()");
+  });
+});
+describeRule("legacy-zui-examples-should-be-removed", (lint) => {
+  (0, import_vitest.test)("legacy zui examples should trigger", async () => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { [LEGACY_ZUI]: { [PARAM_NAME]: { examples: [TRUTHY_STRING] } }, schema: {} } }
+      },
+      configuration: {
+        [LEGACY_ZUI]: { [PARAM_NAME]: { examples: [TRUTHY_STRING] } },
+        schema: {}
+      },
+      events: { [EVENT_NAME]: { [LEGACY_ZUI]: { [PARAM_NAME]: { examples: [TRUTHY_STRING] } }, schema: {} } },
+      channels: {
+        [CHANNEL_NAME]: {
+          messages: { [MESSAGE_TYPE]: { [LEGACY_ZUI]: { [PARAM_NAME]: { examples: [TRUTHY_STRING] } }, schema: {} } }
+        }
+      },
+      states: { [STATE_NAME]: { [LEGACY_ZUI]: { [PARAM_NAME]: { examples: [TRUTHY_STRING] } }, schema: {} } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(5);
+    (0, import_vitest.expect)(results[0]?.message).toContain("examples");
+  });
+});
+describeRule("state-fields-should-have-title", (lint) => {
+  (0, import_vitest.test)("missing title should trigger", async () => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: {} } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["states", STATE_NAME, "schema", "properties", PARAM_NAME, ZUI]);
+  });
+  (0, import_vitest.test)("empty title should trigger", async () => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: EMPTY_STRING } } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["states", STATE_NAME, "schema", "properties", PARAM_NAME, ZUI, "title"]);
+  });
+  (0, import_vitest.test)("valid title should not trigger", async () => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [PARAM_NAME]: { [ZUI]: { title: TRUTHY_STRING } } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("state-fields-must-have-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [PARAM_NAME]: {} } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["states", STATE_NAME, "schema", "properties", PARAM_NAME]);
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [PARAM_NAME]: { description: EMPTY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["states", STATE_NAME, "schema", "properties", PARAM_NAME, "description"]);
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [PARAM_NAME]: { description: TRUTHY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+//# sourceMappingURL=integration.ruleset.test.js.map