@botpress/cli 5.0.1 → 5.0.3

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

@@ -25,6 +25,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: {
@@ -36,6 +54,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: {
@@ -45,6 +97,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) => {
@@ -56,6 +128,26 @@ 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: {
@@ -75,6 +167,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: {
@@ -84,6 +206,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) => {
@@ -95,6 +234,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: {
@@ -115,6 +272,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: {
@@ -124,6 +315,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) => {
@@ -135,6 +346,20 @@ 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: {
@@ -154,6 +379,34 @@ 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: {
@@ -163,6 +416,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) => {
@@ -174,6 +444,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: {
@@ -185,6 +471,34 @@ 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: {
@@ -194,6 +508,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) => {
@@ -205,6 +537,22 @@ 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: {
@@ -216,6 +564,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: {
@@ -225,6 +598,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("legacy-zui-title-should-be-removed", (lint) => {
   import_vitest.test.each(PARAM_NAMES)("legacy zui title should trigger (%s)", async (paramName) => {
@@ -328,6 +714,22 @@ describeRule("entity-fields-should-have-a-title", (lint) => {
     (0, import_vitest.expect)(results[0]?.path).toEqual(["entities", ENTITY_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 = {
+      entities: {
+        [ENTITY_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(["entities", ENTITY_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 = {
       entities: {
@@ -339,6 +741,34 @@ describeRule("entity-fields-should-have-a-title", (lint) => {
     (0, import_vitest.expect)(results[0]?.path).toEqual(["entities", ENTITY_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 = {
+      entities: {
+        [ENTITY_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([
+      "entities",
+      ENTITY_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 = {
       entities: {
@@ -348,6 +778,24 @@ describeRule("entity-fields-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 = {
+      entities: {
+        [ENTITY_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("entity-fields-must-have-a-description", (lint) => {
   import_vitest.test.each(PARAM_NAMES)("missing description should trigger (%s)", async (paramName) => {
@@ -359,6 +807,22 @@ describeRule("entity-fields-must-have-a-description", (lint) => {
     (0, import_vitest.expect)(results[0]?.path).toEqual(["entities", ENTITY_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 = {
+      entities: {
+        [ENTITY_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(["entities", ENTITY_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 = {
       entities: {
@@ -370,6 +834,31 @@ describeRule("entity-fields-must-have-a-description", (lint) => {
     (0, import_vitest.expect)(results[0]?.path).toEqual(["entities", ENTITY_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 = {
+      entities: {
+        [ENTITY_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([
+      "entities",
+      ENTITY_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 = {
       entities: {
@@ -379,5 +868,18 @@ describeRule("entity-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 = {
+      entities: {
+        [ENTITY_NAME]: {
+          schema: {
+            properties: { [paramName]: { anyOf: [{ type: "object", description: TRUTHY_STRING }, { type: "null" }] } }
+          }
+        }
+      }
+    };
+    const results = await lint(definition);
+    (0, import_vitest.expect)(results).toHaveLength(0);
+  });
 });
 //# sourceMappingURL=interface.ruleset.test.js.map