@botpress/cli 5.0.1 → 5.0.2

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

@@ -150,6 +150,24 @@ describeRule("action-inputparams-should-have-a-title", (lint) => {
     (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)("missing title with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          input: {
+            schema: {
+              properties: { [paramName]: { anyOf: [{ type: "object", [ZUI]: {} }, { type: "null" }], [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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
     const definition = {
       actions: {
@@ -161,6 +179,40 @@ describeRule("action-inputparams-should-have-a-title", (lint) => {
     (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)("empty title nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          input: {
+            schema: {
+              properties: {
+                [paramName]: {
+                  anyOf: [{ type: "object", [ZUI]: { title: EMPTY_STRING } }, { type: "null" }],
+                  [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,
+      "anyOf",
+      "0",
+      ZUI,
+      "title"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
     const definition = {
       actions: {
@@ -170,6 +222,26 @@ describeRule("action-inputparams-should-have-a-title", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid title nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          input: {
+            schema: {
+              properties: {
+                [paramName]: {
+                  anyOf: [{ type: "object", [ZUI]: { title: TRUTHY_STRING } }, { type: "null" }],
+                  [ZUI]: {}
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    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) => {
@@ -181,6 +253,24 @@ describeRule("action-inputparams-must-have-a-description", (lint) => {
     (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)("missing description with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          input: {
+            schema: {
+              properties: { [paramName]: { anyOf: [{ type: "object" }, { type: "null" }] } }
+            }
+          }
+        }
+      }
+    };
+    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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
     const definition = {
       actions: {
@@ -200,6 +290,36 @@ describeRule("action-inputparams-must-have-a-description", (lint) => {
     ]);
     (0, import_vitest.expect)(results[0]?.message).toContain("description");
   });
+  import_vitest.test.each(PARAM_NAMES)("empty description nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          input: {
+            schema: {
+              properties: {
+                [paramName]: { anyOf: [{ type: "object", description: EMPTY_STRING }, { type: "null" }] }
+              }
+            }
+          }
+        }
+      }
+    };
+    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,
+      "anyOf",
+      "0",
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
     const definition = {
       actions: {
@@ -209,6 +329,23 @@ describeRule("action-inputparams-must-have-a-description", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid description nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          input: {
+            schema: {
+              properties: {
+                [paramName]: { anyOf: [{ type: "object", description: TRUTHY_STRING }, { type: "null" }] }
+              }
+            }
+          }
+        }
+      }
+    };
+    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) => {
@@ -220,6 +357,24 @@ describeRule("action-outputparams-should-have-a-title", (lint) => {
     (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)("missing title with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          output: {
+            schema: {
+              properties: { [paramName]: { anyOf: [{ type: "object", [ZUI]: {} }, { type: "null" }], [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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
     const definition = {
       actions: {
@@ -240,6 +395,40 @@ describeRule("action-outputparams-should-have-a-title", (lint) => {
     ]);
     (0, import_vitest.expect)(results[0]?.message).toContain("title");
   });
+  import_vitest.test.each(PARAM_NAMES)("empty title nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          output: {
+            schema: {
+              properties: {
+                [paramName]: {
+                  anyOf: [{ type: "object", [ZUI]: { title: EMPTY_STRING } }, { type: "null" }],
+                  [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,
+      "anyOf",
+      "0",
+      ZUI,
+      "title"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
     const definition = {
       actions: {
@@ -249,6 +438,26 @@ describeRule("action-outputparams-should-have-a-title", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid title nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          output: {
+            schema: {
+              properties: {
+                [paramName]: {
+                  anyOf: [{ type: "object", [ZUI]: { title: TRUTHY_STRING } }, { type: "null" }],
+                  [ZUI]: {}
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    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) => {
@@ -260,6 +469,24 @@ describeRule("action-outputparams-must-have-a-description", (lint) => {
     (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)("missing description with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          output: {
+            schema: {
+              properties: { [paramName]: { anyOf: [{ type: "object" }, { type: "null" }] } }
+            }
+          }
+        }
+      }
+    };
+    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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
     const definition = {
       actions: {
@@ -279,6 +506,36 @@ describeRule("action-outputparams-must-have-a-description", (lint) => {
     ]);
     (0, import_vitest.expect)(results[0]?.message).toContain("description");
   });
+  import_vitest.test.each(PARAM_NAMES)("empty description nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          output: {
+            schema: {
+              properties: {
+                [paramName]: { anyOf: [{ type: "object", description: EMPTY_STRING }, { type: "null" }] }
+              }
+            }
+          }
+        }
+      }
+    };
+    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,
+      "anyOf",
+      "0",
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
     const definition = {
       actions: {
@@ -288,6 +545,23 @@ describeRule("action-outputparams-must-have-a-description", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid description nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      actions: {
+        [ACTION_NAME]: {
+          output: {
+            schema: {
+              properties: {
+                [paramName]: { anyOf: [{ type: "object", description: TRUTHY_STRING }, { type: "null" }] }
+              }
+            }
+          }
+        }
+      }
+    };
+    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) => {
@@ -299,6 +573,22 @@ describeRule("event-outputparams-should-have-title", (lint) => {
     (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)("missing title with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: {
+          schema: {
+            properties: { [paramName]: { anyOf: [{ type: "object", [ZUI]: {} }, { type: "null" }], [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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
     const definition = {
       events: {
@@ -310,6 +600,37 @@ describeRule("event-outputparams-should-have-title", (lint) => {
     (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)("empty title nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: {
+                anyOf: [{ type: "object", [ZUI]: { title: EMPTY_STRING } }, { type: "null" }],
+                [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,
+      "anyOf",
+      "0",
+      ZUI,
+      "title"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
     const definition = {
       events: {
@@ -319,6 +640,24 @@ describeRule("event-outputparams-should-have-title", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid title nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: {
+                anyOf: [{ type: "object", [ZUI]: { title: TRUTHY_STRING } }, { type: "null" }],
+                [ZUI]: {}
+              }
+            }
+          }
+        }
+      }
+    };
+    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) => {
@@ -330,6 +669,20 @@ describeRule("event-outputparams-must-have-description", (lint) => {
     (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)("missing description with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: {
+          schema: { properties: { [paramName]: { anyOf: [{ type: "object" }, { type: "null" }] } } }
+        }
+      }
+    };
+    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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
     const definition = {
       events: {
@@ -341,6 +694,31 @@ describeRule("event-outputparams-must-have-description", (lint) => {
     (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)("empty description nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: {
+          schema: {
+            properties: { [paramName]: { anyOf: [{ type: "object", description: EMPTY_STRING }, { type: "null" }] } }
+          }
+        }
+      }
+    };
+    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,
+      "anyOf",
+      "0",
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
     const definition = {
       events: {
@@ -350,6 +728,19 @@ describeRule("event-outputparams-must-have-description", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid description nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      events: {
+        [EVENT_NAME]: {
+          schema: {
+            properties: { [paramName]: { anyOf: [{ type: "object", description: TRUTHY_STRING }, { type: "null" }] } }
+          }
+        }
+      }
+    };
+    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 () => {
@@ -405,6 +796,20 @@ describeRule("configuration-fields-must-have-a-title", (lint) => {
     (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)("missing title with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: {
+        schema: {
+          properties: { [paramName]: { anyOf: [{ type: "object", [ZUI]: {} }, { type: "null" }], [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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
     const definition = {
       configuration: { schema: { properties: { [paramName]: { [ZUI]: { title: EMPTY_STRING } } } } }
@@ -414,6 +819,22 @@ describeRule("configuration-fields-must-have-a-title", (lint) => {
     (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)("empty title nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: {
+        schema: {
+          properties: {
+            [paramName]: { anyOf: [{ type: "object", [ZUI]: { title: EMPTY_STRING } }, { type: "null" }], [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, "anyOf", "0", ZUI, "title"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
     const definition = {
       configuration: { schema: { properties: { [paramName]: { [ZUI]: { title: TRUTHY_STRING } } } } }
@@ -421,6 +842,19 @@ describeRule("configuration-fields-must-have-a-title", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid title nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: {
+        schema: {
+          properties: {
+            [paramName]: { anyOf: [{ type: "object", [ZUI]: { title: TRUTHY_STRING } }, { type: "null" }], [ZUI]: {} }
+          }
+        }
+      }
+    };
+    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) => {
@@ -432,6 +866,16 @@ describeRule("configuration-fields-must-have-a-description", (lint) => {
     (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)("missing description with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: { schema: { properties: { [paramName]: { anyOf: [{ type: "object" }, { type: "null" }] } } } }
+    };
+    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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
     const definition = {
       configuration: { schema: { properties: { [paramName]: { description: EMPTY_STRING } } } }
@@ -441,6 +885,20 @@ describeRule("configuration-fields-must-have-a-description", (lint) => {
     (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)("empty description nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: {
+        schema: {
+          properties: { [paramName]: { anyOf: [{ type: "object", description: EMPTY_STRING }, { type: "null" }] } }
+        }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(1);
+    (0, import_vitest.expect)(results[0]?.path).toEqual(["configuration", "schema", "properties", paramName, "anyOf", "0", "description"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
     const definition = {
       configuration: { schema: { properties: { [paramName]: { description: TRUTHY_STRING } } } }
@@ -448,6 +906,17 @@ describeRule("configuration-fields-must-have-a-description", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid description nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      configuration: {
+        schema: {
+          properties: { [paramName]: { anyOf: [{ type: "object", description: TRUTHY_STRING }, { type: "null" }] } }
+        }
+      }
+    };
+    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 () => {
@@ -513,6 +982,24 @@ describeRule("multipes-configurations-fields-must-have-a-title", (lint) => {
     (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)("missing title with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: { anyOf: [{ type: "object", [ZUI]: {} }, { type: "null" }], [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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
     const definition = {
       configurations: {
@@ -524,6 +1011,34 @@ describeRule("multipes-configurations-fields-must-have-a-title", (lint) => {
     (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)("empty title nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: { anyOf: [{ type: "object", [ZUI]: { title: EMPTY_STRING } }, { type: "null" }], [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,
+      "anyOf",
+      "0",
+      ZUI,
+      "title"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
     const definition = {
       configurations: {
@@ -533,6 +1048,24 @@ describeRule("multipes-configurations-fields-must-have-a-title", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid title nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: {
+                anyOf: [{ type: "object", [ZUI]: { title: TRUTHY_STRING } }, { type: "null" }],
+                [ZUI]: {}
+              }
+            }
+          }
+        }
+      }
+    };
+    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) => {
@@ -544,6 +1077,24 @@ describeRule("multipes-configurations-fields-must-have-a-description", (lint) =>
     (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)("missing description with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: { anyOf: [{ type: "object" }, { type: "null" }] }
+            }
+          }
+        }
+      }
+    };
+    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");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
     const definition = {
       configurations: {
@@ -555,6 +1106,33 @@ describeRule("multipes-configurations-fields-must-have-a-description", (lint) =>
     (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)("empty description nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: { anyOf: [{ type: "object", description: EMPTY_STRING }, { type: "null" }] }
+            }
+          }
+        }
+      }
+    };
+    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,
+      "anyOf",
+      "0",
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
+  });
   import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
     const definition = {
       configurations: {
@@ -564,6 +1142,21 @@ describeRule("multipes-configurations-fields-must-have-a-description", (lint) =>
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid description nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      configurations: {
+        [CONFIG_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: { anyOf: [{ type: "object", description: TRUTHY_STRING }, { type: "null" }] }
+            }
+          }
+        }
+      }
+    };
+    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 () => {
@@ -821,6 +1414,23 @@ describeRule("state-fields-should-have-title", (lint) => {
     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]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("missing title with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      states: {
+        [STATE_NAME]: {
+          schema: {
+            properties: { [paramName]: { anyOf: [{ type: "object", [ZUI]: {} }, { type: "null" }], [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]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
   });
   import_vitest.test.each(PARAM_NAMES)("empty title should trigger (%s)", async (paramName) => {
     const definition = {
@@ -829,6 +1439,35 @@ describeRule("state-fields-should-have-title", (lint) => {
     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"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty title nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      states: {
+        [STATE_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: { anyOf: [{ type: "object", [ZUI]: { title: EMPTY_STRING } }, { type: "null" }], [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,
+      "anyOf",
+      "0",
+      ZUI,
+      "title"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("title");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
   });
   import_vitest.test.each(PARAM_NAMES)("valid title should not trigger (%s)", async (paramName) => {
     const definition = {
@@ -837,6 +1476,24 @@ describeRule("state-fields-should-have-title", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid title nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      states: {
+        [STATE_NAME]: {
+          schema: {
+            properties: {
+              [paramName]: {
+                anyOf: [{ type: "object", [ZUI]: { title: TRUTHY_STRING } }, { type: "null" }],
+                [ZUI]: {}
+              }
+            }
+          }
+        }
+      }
+    };
+    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) => {
@@ -846,6 +1503,23 @@ describeRule("state-fields-must-have-description", (lint) => {
     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]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("missing description with anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      states: {
+        [STATE_NAME]: {
+          schema: {
+            properties: { [paramName]: { anyOf: [{ type: "object" }, { type: "null" }] } }
+          }
+        }
+      }
+    };
+    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]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
   });
   import_vitest.test.each(PARAM_NAMES)("empty description should trigger (%s)", async (paramName) => {
     const definition = {
@@ -854,6 +1528,32 @@ describeRule("state-fields-must-have-description", (lint) => {
     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"]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+  });
+  import_vitest.test.each(PARAM_NAMES)("empty description nested in anyOf should trigger (%s)", async (paramName) => {
+    const definition = {
+      states: {
+        [STATE_NAME]: {
+          schema: {
+            properties: { [paramName]: { anyOf: [{ type: "object", description: EMPTY_STRING }, { type: "null" }] } }
+          }
+        }
+      }
+    };
+    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,
+      "anyOf",
+      "0",
+      "description"
+    ]);
+    (0, import_vitest.expect)(results[0]?.message).toContain("description");
+    (0, import_vitest.expect)(results[0]?.message).toContain(paramName);
   });
   import_vitest.test.each(PARAM_NAMES)("valid description should not trigger (%s)", async (paramName) => {
     const definition = {
@@ -862,6 +1562,19 @@ describeRule("state-fields-must-have-description", (lint) => {
     const results = await lint(definition);
     (0, import_vitest.expect)(results).toHaveLength(0);
   });
+  import_vitest.test.each(PARAM_NAMES)("valid description nested in anyOf should not trigger (%s)", async (paramName) => {
+    const definition = {
+      states: {
+        [STATE_NAME]: {
+          schema: {
+            properties: { [paramName]: { anyOf: [{ type: "object", description: TRUTHY_STRING }, { type: "null" }] } }
+          }
+        }
+      }
+    };
+    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 () => {