@botpress/adk-cli 1.3.0 → 1.4.0

package/dist/bp-cli/dist/linter/ruleset-tests/integration.ruleset.test.js

@@ -0,0 +1,887 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_integration = require("../rulesets/integration.ruleset");
+var import_common = require("./common");
+const describeRule = (0, import_common.createDescribeRule)()(import_integration.INTEGRATION_RULESET);
+const EMPTY_STRING = "";
+const TRUTHY_STRING = "truthy";
+const ACTION_NAME = "actionName";
+const EVENT_NAME = "eventName";
+const CONFIG_NAME = "configName";
+const PARAM_NAME = "paramName";
+const PROPERTIES_PARAM = "properties";
+const PARAM_NAMES = [PARAM_NAME, PROPERTIES_PARAM];
+const TAG_NAME = "tagName";
+const CHANNEL_NAME = "channelName";
+const STATE_NAME = "stateName";
+const SECRET_NAME = "SECRET_NAME";
+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) => {
+  import_vitest.test.each(PARAM_NAMES)("missing title should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: { [ACTION_NAME]: { input: { schema: { properties: { [paramName]: { [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", paramName, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { schema: { properties: { [paramName]: { [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", paramName, ZUI, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { schema: { properties: { [paramName]: { [ZUI]: { title: TRUTHY_STRING } } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("action-inputparams-must-have-a-description", (lint) => {
+  import_vitest.test.each(PARAM_NAMES)("missing description should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: { [ACTION_NAME]: { input: { schema: { properties: { [paramName]: {} } } } } }
+    };
+    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", paramName]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { schema: { properties: { [paramName]: { 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",
+      paramName,
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { schema: { properties: { [paramName]: { description: TRUTHY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("action-outputparams-should-have-a-title", (lint) => {
+  import_vitest.test.each(PARAM_NAMES)("missing title should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: { [ACTION_NAME]: { output: { schema: { properties: { [paramName]: { [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", paramName, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { output: { schema: { properties: { [paramName]: { [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",
+      paramName,
+      ZUI,
+      "title"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { output: { schema: { properties: { [paramName]: { [ZUI]: { title: TRUTHY_STRING } } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("action-outputparams-must-have-a-description", (lint) => {
+  import_vitest.test.each(PARAM_NAMES)("missing description should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: { [ACTION_NAME]: { output: { schema: { properties: { [paramName]: {} } } } } }
+    };
+    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", paramName]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { output: { schema: { properties: { [paramName]: { 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",
+      paramName,
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { output: { schema: { properties: { [paramName]: { description: TRUTHY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("event-outputparams-should-have-title", (lint) => {
+  import_vitest.test.each(PARAM_NAMES)("missing title should trigger (%s)", async (paramName) => {
+    const definition = {
+      events: { [EVENT_NAME]: { schema: { properties: { [paramName]: { [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", paramName, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: { schema: { properties: { [paramName]: { [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", paramName, ZUI, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: { schema: { properties: { [paramName]: { [ZUI]: { title: TRUTHY_STRING } } } } }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("event-outputparams-must-have-description", (lint) => {
+  import_vitest.test.each(PARAM_NAMES)("missing description should trigger (%s)", async (paramName) => {
+    const definition = {
+      events: { [EVENT_NAME]: { schema: { properties: { [paramName]: {} } } } }
+    };
+    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", paramName]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: { schema: { properties: { [paramName]: { 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", paramName, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: { schema: { properties: { [paramName]: { 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) => {
+  import_vitest.test.each(PARAM_NAMES)("missing title should trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: { schema: { properties: { [paramName]: { [ZUI]: {} } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configuration", "schema", "properties", paramName, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: { schema: { properties: { [paramName]: { [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", paramName, ZUI, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: { schema: { properties: { [paramName]: { [ZUI]: { title: TRUTHY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("configuration-fields-must-have-a-description", (lint) => {
+  import_vitest.test.each(PARAM_NAMES)("missing description should trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: { schema: { properties: { [paramName]: {} } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configuration", "schema", "properties", paramName]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: { schema: { properties: { [paramName]: { description: 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", paramName, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: { schema: { properties: { [paramName]: { description: 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) => {
+  import_vitest.test.each(PARAM_NAMES)("missing title should trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: { schema: { properties: { [paramName]: { [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", paramName, ZUI]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: { schema: { properties: { [paramName]: { [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", paramName, ZUI, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: { schema: { properties: { [paramName]: { [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) => {
+  import_vitest.test.each(PARAM_NAMES)("missing description should trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: { [CONFIG_NAME]: { schema: { properties: { [paramName]: {} } } } }
+    };
+    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", paramName]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: { schema: { properties: { [paramName]: { 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", paramName, "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: { schema: { properties: { [paramName]: { 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) => {
+  import_vitest.test.each(PARAM_NAMES)("legacy zui title should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { [LEGACY_ZUI]: { [paramName]: { title: TRUTHY_STRING } }, schema: {} } }
+      },
+      configuration: {
+        [LEGACY_ZUI]: { [paramName]: { title: TRUTHY_STRING } },
+        schema: {}
+      },
+      events: { [EVENT_NAME]: { [LEGACY_ZUI]: { [paramName]: { title: TRUTHY_STRING } }, schema: {} } },
+      channels: {
+        [CHANNEL_NAME]: {
+          messages: { [MESSAGE_TYPE]: { [LEGACY_ZUI]: { [paramName]: { title: TRUTHY_STRING } }, schema: {} } }
+        }
+      },
+      states: { [STATE_NAME]: { [LEGACY_ZUI]: { [paramName]: { 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) => {
+  import_vitest.test.each(PARAM_NAMES)("legacy zui examples should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: { input: { [LEGACY_ZUI]: { [paramName]: { examples: [TRUTHY_STRING] } }, schema: {} } }
+      },
+      configuration: {
+        [LEGACY_ZUI]: { [paramName]: { examples: [TRUTHY_STRING] } },
+        schema: {}
+      },
+      events: { [EVENT_NAME]: { [LEGACY_ZUI]: { [paramName]: { examples: [TRUTHY_STRING] } }, schema: {} } },
+      channels: {
+        [CHANNEL_NAME]: {
+          messages: { [MESSAGE_TYPE]: { [LEGACY_ZUI]: { [paramName]: { examples: [TRUTHY_STRING] } }, schema: {} } }
+        }
+      },
+      states: { [STATE_NAME]: { [LEGACY_ZUI]: { [paramName]: { 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) => {
+  import_vitest.test.each(PARAM_NAMES)("missing title should trigger (%s)", async (paramName) => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [paramName]: { [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", paramName, ZUI]);
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [paramName]: { [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", paramName, ZUI, "title"]);
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [paramName]: { [ZUI]: { title: TRUTHY_STRING } } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("state-fields-must-have-description", (lint) => {
+  import_vitest.test.each(PARAM_NAMES)("missing description should trigger (%s)", async (paramName) => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [paramName]: {} } } } }
+    };
+    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", paramName]);
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [paramName]: { 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", paramName, "description"]);
+  });
+  import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
+    const definition = {
+      states: { [STATE_NAME]: { schema: { properties: { [paramName]: { description: TRUTHY_STRING } } } } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+describeRule("secrets-must-have-a-description", (lint) => {
+  (0, import_vitest.test)("missing description should trigger", async () => {
+    const definition = { secrets: { [SECRET_NAME]: {} } };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+  });
+  (0, import_vitest.test)("empty description should trigger", async () => {
+    const definition = {
+      secrets: { [SECRET_NAME]: { description: EMPTY_STRING } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+  });
+  (0, import_vitest.test)("valid description should not trigger", async () => {
+    const definition = {
+      secrets: { [SECRET_NAME]: { description: TRUTHY_STRING } }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
+});
+//# sourceMappingURL=integration.ruleset.test.js.map