@geonosis/oxlint-plugin-biological-architecture 3.1.0 → 3.2.0

package/dist/rules/compound-must-be-stateless.js

@@ -1,6 +1,7 @@
 // src/rules/compound-must-be-stateless.ts
 import { hookCalledBy } from "./lib/hooks.js";
-import { normalise } from "./lib/paths.js";
+import { normalise, fileOf } from "./lib/paths.js";
+import { inTier } from "./lib/tiers.js";
 var reactForbiddenHooks = new Set([
   "useCallback",
   "useEffect",
@@ -12,49 +13,35 @@ var reactForbiddenHooks = new Set([
   "useState"
 ]);
 var CONTEXT_MODULE = /(?:^|\/)(?:providers|contexts)\//;
-var COMPOUND_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?compounds\//;
 var compoundMustBeStateless = {
   create(context) {
-    const filename = context.filename;
-    const normalized = normalise(filename);
-    const isCompound = COMPOUND_FILE_PATTERN.test(normalized);
-    if (!isCompound)
+    const normalized = normalise(context.filename);
+    if (!inTier(normalized, "compounds"))
       return {};
-    const shortName = normalized.split("/").pop() || normalized;
+    const shortName = fileOf(normalized);
     return {
       CallExpression(node) {
-        const name = hookCalledBy(node);
-        if (name === null)
+        const hook = hookCalledBy(node);
+        if (hook === null)
           return;
-        context.report({
-          data: { file: shortName, hook: name },
-          messageId: "forbiddenHookCall",
-          node
-        });
+        context.report({ data: { file: shortName, hook }, messageId: "forbiddenHookCall", node });
       },
       ImportDeclaration(node) {
         if (node.importKind === "type")
           return;
         const source = node.source.value;
         if (source === "react") {
-          const specifiers = node.specifiers ?? [];
-          for (const spec of specifiers) {
-            if (spec.type !== "ImportSpecifier")
-              continue;
-            const importedName = spec.imported?.name;
-            if (!importedName)
-              continue;
-            if (reactForbiddenHooks.has(importedName)) {
+          for (const specifier of node.specifiers ?? []) {
+            const hook = specifier.type === "ImportSpecifier" ? specifier.imported?.name : undefined;
+            if (hook !== undefined && reactForbiddenHooks.has(hook)) {
               context.report({
-                data: { file: shortName, hook: importedName },
+                data: { file: shortName, hook },
                 messageId: "forbiddenReactHook",
                 node
               });
             }
           }
-          return;
-        }
-        if (CONTEXT_MODULE.test(source)) {
+        } else if (CONTEXT_MODULE.test(source)) {
           context.report({
             data: { file: shortName, source },
             messageId: "forbiddenContextImport",
@@ -78,6 +65,17 @@ organelle and holds it; if the file itself needs state, it is not a compound.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/compounds/geonosis-probe.tsx",
+      source: `declare const useGeonosisThing: () => boolean
+
+export function GeonosisProbe() {
+  return useGeonosisThing() ? 'a' : 'b'
+}
+`
+    };
   }
 };
 var compound_must_be_stateless_default = compoundMustBeStateless;

package/dist/rules/compound-no-stores.d.ts

@@ -9,6 +9,7 @@ declare const compoundNoStores: {
         }) => void;
     }): import('./lib/visitors.js').Visitor;
     fixShape: string;
+    probe?: ((options: readonly unknown[]) => import('./lib/probe.js').Probe | import('./lib/probe.js').ProbeTree) | undefined;
     meta: {
         docs: {
             description: string;

package/dist/rules/compound-no-stores.js

@@ -1,23 +1,25 @@
 // src/rules/compound-no-stores.ts
 import { directionRule } from "./lib/direction-rule.js";
-var FORBIDDEN_PATTERNS = [
-  /(?:^|\/)stores\//,
-  /(?:^|\/)organelles\//,
-  /(?:^|\/)cells\//,
-  /(?:^|\/)tissues\//,
-  /(?:^|\/)layouts\//,
-  /\/app\//
-];
+import { isTestFile } from "./lib/paths.js";
+import { inTiersAbove, APP_FOLDER, LAYOUTS_FOLDER, STORES_FOLDER } from "./lib/tiers.js";
+var FORBIDDEN_PATTERNS = [STORES_FOLDER, LAYOUTS_FOLDER, APP_FOLDER];
 var compoundNoStores = directionRule({
   description: "Compounds may only import atoms, molecules, and other compounds. They cannot import organelles, cells, tissues, stores, or app routes — direction rule: a parent may only compose children at levels <= its own.",
   fixShape: `A compound may import atoms, molecules and other compounds. Stores, organelles, cells, tissues,
 layouts and app routes are all above it. Take the data as a prop from the cell that reads the store.
 Type-only imports are exempt; \`export … from\` is not.`,
-  forbidden: (target) => FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
+  forbidden: (target) => inTiersAbove(target.path, "compounds") || FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
   messages: {
     forbidden: "Compounds cannot import from {{source}}. Direction violation — compounds are level 3 and can only depend on atoms, molecules, other compounds, and shared libs/domains/types."
   },
-  scope: (importer) => importer.tier === "compounds" && !/__tests__\//.test(importer.path)
+  probe: () => ({
+    path: "src/compounds/geonosis-probe.tsx",
+    source: `import { up } from '../stores/geonosis-up'
+
+export const GeonosisProbe = up
+`
+  }),
+  scope: (importer) => importer.tier === "compounds" && !isTestFile(importer.path)
 });
 var compound_no_stores_default = compoundNoStores;
 export {

package/dist/rules/constants-in-constants-file.d.ts

@@ -1,3 +1,4 @@
+import { type RuleContext } from './lib/context.js';
 type Declarator = {
     type: string;
     id: {
@@ -14,14 +15,7 @@ type ExportNamedDeclaration = {
     } | null;
 };
 declare const constantsInConstantsFile: {
-    create(context: {
-        filename: string;
-        report: (d: {
-            messageId: string;
-            node: unknown;
-            data: Record<string, string>;
-        }) => void;
-    }): {
+    create(context: RuleContext): {
         ExportNamedDeclaration?: undefined;
     } | {
         ExportNamedDeclaration(node: ExportNamedDeclaration): void;

package/dist/rules/constants-in-constants-file.js

@@ -1,21 +1,20 @@
 // src/rules/constants-in-constants-file.ts
-import { normalise } from "./lib/paths.js";
+import { matchesAny, normalise } from "./lib/paths.js";
 var exemptFiles = [/\/constants\.ts$/, /\/__tests__\//, /\/scripts\//, /\/testing\//, /\.d\.ts$/];
 var screamingSnake = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/;
 var constantsInConstantsFile = {
   create(context) {
-    const normalized = normalise(context.filename);
-    if (exemptFiles.some((file) => file.test(normalized)))
+    if (matchesAny(exemptFiles, normalise(context.filename)))
       return {};
     return {
       ExportNamedDeclaration(node) {
-        const declaration = node.declaration;
-        if (!declaration || declaration.type !== "VariableDeclaration")
+        const { declaration } = node;
+        if (declaration?.type !== "VariableDeclaration")
           return;
         for (const declarator of declaration.declarations ?? []) {
           const name = declarator.id.type === "Identifier" ? declarator.id.name : undefined;
           if (name !== undefined && name.length >= 3 && screamingSnake.test(name)) {
-            context.report({ messageId: "outsideConstantsFile", node, data: { name } });
+            context.report({ data: { name }, messageId: "outsideConstantsFile", node });
           }
         }
       }

package/dist/rules/dialect-through-the-seam.d.ts

@@ -1,15 +1,7 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /**
-     * Regex sources over the normalised filename: the files the Postgres-word check leaves alone —
-     * test helpers, fixtures. Naming any REPLACES the test-path default.
-     */
     exempt?: string | string[];
-    /**
-     * Regex sources over the normalised filename: the only files that may name a dialect or driver
-     * module — the schema, the dialect module, the client, the drivers, drizzle-kit's configs.
-     */
     seam?: string | string[];
 }
 declare const dialectThroughTheSeam: {
@@ -53,11 +45,6 @@ declare const dialectThroughTheSeam: {
         }[];
         type: 'problem';
     };
-    /**
-     * A file OUTSIDE the seam importing the dialect — the inverse of a probe placed where its option
-     * points. Tried against the repo's own `seam`: a seam broad enough to swallow every candidate has
-     * configured a rule that can never fire, and the probe says so rather than calling it green.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default dialectThroughTheSeam;

package/dist/rules/durable-body-reads-through-steps.d.ts

@@ -2,21 +2,11 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The config key that marks a workflow durable. Default: the engine's `execution`. */
     durableKey?: string;
-    /** What that key must say. Default: the engine's `'durable'`. */
     durableValue?: boolean | string;
-    /** The identifiers a body reaches the outside world through — this repo's ports. */
     ports?: string[];
-    /**
-     * The receivers whose calls the ENGINE has already made steps of — `stepsOf`' proxy over a module
-     * of bound queries. A call through one is journalled under its own name and answered from the
-     * record on a replay, so it is exactly what this rule asks for rather than what it forbids.
-     */
     stepProxies?: string[];
-    /** The call names that define a step. Default: `createStep`. */
     stepFactories?: string[];
-    /** The call names that define a workflow. Default: `createWorkflow`. */
     workflowFactories?: string[];
 }
 declare const durableBodyReadsThroughSteps: {
@@ -69,10 +59,6 @@ declare const durableBodyReadsThroughSteps: {
         }[];
         type: 'problem';
     };
-    /**
-     * A durable body with one free read and no step at all: a step would be the remedy, and a probe
-     * that carried one would be claiming a finding from the shape the rule accepts.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default durableBodyReadsThroughSteps;

package/dist/rules/durable-body-reads-through-steps.js

@@ -4,10 +4,15 @@ import { propertiesOf, stringOf, valueOf } from "./lib/objects.js";
 import { requireOption } from "./lib/options.js";
 import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
-import { argumentsOf, isStepCall, stepFactoriesOf } from "./lib/steps.js";
+import {
+  argumentsOf,
+  DEFAULT_WORKFLOW_FACTORIES,
+  isStepCall,
+  stepFactoriesOf,
+  workflowFactoriesOf
+} from "./lib/steps.js";
 var RULE = "durable-body-reads-through-steps";
 var ACCEPTS = "{ ports: string[] (required), durableKey: string, durableValue: boolean | string, workflowFactories: string[], stepFactories: string[], stepProxies: string[] }";
-var DEFAULT_WORKFLOW_FACTORIES = ["createWorkflow"];
 var DEFAULT_DURABLE_KEY = "execution";
 var DEFAULT_DURABLE_VALUE = "durable";
 var declaresDurable = (node, key, value) => argumentsOf(node).some((argument) => {
@@ -44,7 +49,7 @@ var durableBodyReadsThroughSteps = {
     const ports = new Set(requireOption(RULE, bag.ports, "ports", ACCEPTS));
     const proxies = new Set(bag.stepProxies ?? []);
     const steps = stepFactoriesOf(RULE, bag.stepFactories);
-    const workflows = new Set(requireOption(RULE, bag.workflowFactories ?? DEFAULT_WORKFLOW_FACTORIES, "workflowFactories"));
+    const workflows = workflowFactoriesOf(RULE, bag.workflowFactories);
     const durableKey = requireOption(RULE, bag.durableKey ?? DEFAULT_DURABLE_KEY, "durableKey");
     const durableValue = bag.durableValue ?? DEFAULT_DURABLE_VALUE;
     return {

package/dist/rules/effect-hook-naming.d.ts

@@ -1,4 +1,6 @@
 import { type RuleContext } from './lib/context.js';
+import type { AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
 type Declared = {
     declaration?: {
         declarations?: {
@@ -17,20 +19,15 @@ type Declared = {
 };
 declare const effectHookNaming: {
     create(context: RuleContext): {
-        CallExpression?: undefined;
         ExportNamedDeclaration?: undefined;
-        Program?: undefined;
+        ExportDefaultDeclaration?: undefined;
+        CallExpression?: undefined;
         'Program:exit'?: undefined;
     } | {
-        CallExpression(node: {
-            callee: {
-                name?: string;
-                type: string;
-            };
-        }): void;
-        ExportNamedDeclaration(node: Declared): void;
-        Program(node: unknown): void;
-        'Program:exit'(): void;
+        CallExpression(node: AnyNode): void;
+        ExportDefaultDeclaration: (node: Declared) => void;
+        ExportNamedDeclaration: (node: Declared) => void;
+        'Program:exit'(program: unknown): void;
     };
     fixShape: string;
     meta: {
@@ -44,5 +41,6 @@ declare const effectHookNaming: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default effectHookNaming;

package/dist/rules/effect-hook-naming.js

@@ -1,6 +1,7 @@
 // src/rules/effect-hook-naming.ts
-import { normalise } from "./lib/paths.js";
-var HOOK_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?organelles\/.*\.ts$/;
+import { hookNameOf } from "./lib/hooks.js";
+import { normalise, fileOf } from "./lib/paths.js";
+import { inTier } from "./lib/tiers.js";
 var FUNCTION_VALUES = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
 var exportedFunctionsOf = (node) => {
   const declaration = node.declaration;
@@ -13,48 +14,38 @@ var exportedFunctionsOf = (node) => {
 var effectHookNaming = {
   create(context) {
     const normalized = normalise(context.filename);
-    if (!HOOK_FILE_PATTERN.test(normalized))
+    if (!inTier(normalized, "organelles") || !normalized.endsWith(".ts"))
       return {};
-    const file = normalized.split("/").pop() || "";
-    let usesEffect = false;
-    let effectHookName = "";
-    let programNode = null;
+    const file = fileOf(normalized);
+    let effectHook;
     const exportedFunctions = [];
+    const collect = (node) => {
+      exportedFunctions.push(...exportedFunctionsOf(node));
+    };
     return {
       CallExpression(node) {
-        if (node.callee.type !== "Identifier")
-          return;
-        if (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect") {
-          usesEffect = true;
-          effectHookName = node.callee.name;
-        }
-      },
-      ExportNamedDeclaration(node) {
-        exportedFunctions.push(...exportedFunctionsOf(node));
+        const hook = hookNameOf(node);
+        if (hook === "useEffect" || hook === "useLayoutEffect")
+          effectHook = hook;
       },
-      Program(node) {
-        programNode = node;
-      },
-      "Program:exit"() {
-        if (!usesEffect)
+      ExportDefaultDeclaration: collect,
+      ExportNamedDeclaration: collect,
+      "Program:exit"(program) {
+        if (effectHook === undefined)
           return;
         if (!file.endsWith("-effect.ts")) {
           context.report({
-            data: { file, hook: effectHookName, suggested: file.replace(/\.ts$/, "-effect.ts") },
+            data: { file, hook: effectHook, suggested: file.replace(/\.ts$/, "-effect.ts") },
             messageId: "filenameMissingEffect",
-            node: programNode
+            node: program
           });
         }
-        for (const fn of exportedFunctions) {
-          if (!fn.name.endsWith("Effect")) {
+        for (const { name, node } of exportedFunctions) {
+          if (!name.endsWith("Effect")) {
             context.report({
-              data: {
-                hook: effectHookName,
-                name: fn.name,
-                suggested: fn.name + "Effect"
-              },
+              data: { hook: effectHook, name, suggested: `${name}Effect` },
               messageId: "functionMissingEffect",
-              node: fn.node
+              node
             });
           }
         }
@@ -74,6 +65,17 @@ file and the export together — half the pair still fires.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/organelles/use-geonosis-probe-effect.ts",
+      source: `import { useEffect } from 'react'
+
+export function useGeonosisProbe() {
+  useEffect(() => undefined, [])
+}
+`
+    };
   }
 };
 var effect_hook_naming_default = effectHookNaming;

package/dist/rules/emit-declares-attempts.d.ts

@@ -2,18 +2,7 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /**
-     * The functions this repo builds a retry budget with — a Medusa storefront's `retryableEvent`,
-     * which throws on `attempts <= 1` so a call to it IS a budget.
-     *
-     * Empty by default, and naming one changes what an unreadable options bag means. Measured on a
-     * Medusa storefront: all 54 `emitEventStep` sites spell the bag `options: retryableEvent(…)`,
-     * zero literals and zero missing, so the rule said nothing about any of them and "0 findings"
-     * read as coverage while proving only that no bag was absent. Named, the helper passes and any
-     * other call is a budget nobody can check.
-     */
     budgetHelpers?: string[];
-    /** The call names that emit an event. Default: Medusa's `emitEventStep`. */
     emitters?: string[];
 }
 declare const emitDeclaresAttempts: {
@@ -51,12 +40,6 @@ declare const emitDeclaresAttempts: {
         }[];
         type: 'problem';
     };
-    /**
-     * The emit with no budget at all — the shape the rule speaks about first. `emitters` defaults to
-     * Medusa's spelling, so the probe reads the option the way `create` does, default included: a
-     * repo that wraps the emit under its own name gets a probe naming ITS wrapper, and a repo that
-     * does not gets `emitEventStep`.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default emitDeclaresAttempts;

package/dist/rules/emit-declares-attempts.js

@@ -6,10 +6,6 @@ import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 var RULE = "emit-declares-attempts";
 var DEFAULT_EMITTERS = ["emitEventStep"];
-var OPTIONS = "options";
-var ATTEMPTS = "attempts";
-var EVENT_NAME = "eventName";
-var NO_RETRY = 1;
 var emitDeclaresAttempts = {
   create(context) {
     const emitters = new Set(requireOption(RULE, context.options?.[0]?.emitters ?? DEFAULT_EMITTERS, "emitters"));
@@ -22,8 +18,8 @@ var emitDeclaresAttempts = {
         const properties = propertiesOf(node.arguments?.[0]);
         if (properties === null)
           return;
-        const site = stringOf(valueOf(properties, EVENT_NAME)) ?? emitter;
-        const options = valueOf(properties, OPTIONS);
+        const site = stringOf(valueOf(properties, "eventName")) ?? emitter;
+        const options = valueOf(properties, "options");
         if (options !== undefined && options.type !== "ObjectExpression") {
           if (budgetHelpers.size === 0) {
             context.report({ data: { emitter, site }, messageId: "undeclaredHelpers", node });
@@ -42,15 +38,14 @@ var emitDeclaresAttempts = {
         const bag = options === undefined ? [] : propertiesOf(options);
         if (bag === null)
           return;
-        const attempts = valueOf(bag, ATTEMPTS);
+        const attempts = valueOf(bag, "attempts");
         if (attempts === undefined) {
           context.report({ data: { emitter, site }, messageId: "noBudget", node });
           return;
         }
-        if (attempts.type !== "Literal" || typeof attempts.value !== "number")
-          return;
-        if (attempts.value > NO_RETRY)
+        if (attempts.type !== "Literal" || typeof attempts.value !== "number" || attempts.value > 1) {
           return;
+        }
         context.report({
           data: { attempts: String(attempts.value), emitter, site },
           messageId: "tooFew",

package/dist/rules/font-roles-only.d.ts

@@ -2,17 +2,9 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 import { type OpeningElement } from './lib/styling.js';
 interface Options {
-    /** Paths where a family literal is the point — the theme file, an `@font-face` sheet. */
     allow?: string[];
-    /**
-     * The modules this rule does not judge, each written out in full — the enumeration a pattern
-     * cannot be. A glob grants its exemption to wherever it stops and nobody counts what accumulates
-     * on the far side; a list of module names is a number a reader can hold.
-     */
     exemptModules?: string[];
-    /** How a themed family variable is spelled. Default `--font-`. */
     prefix?: string;
-    /** The role names this repo's contract declares. */
     roles?: string[];
 }
 declare const fontRolesOnly: {
@@ -23,11 +15,6 @@ declare const fontRolesOnly: {
     };
     fixShape: string;
     meta: {
-        /**
-         * #139: which option grants by PATTERN and which one ENUMERATES. Declared on the rule so the
-         * doctor needs no list of its own — a rule that gains a path grant and forgets to say so is a
-         * grant nothing counts, which is the defect this pair exists to end.
-         */
         grants: {
             modules: string;
             paths: string;
@@ -68,11 +55,6 @@ declare const fontRolesOnly: {
         }[];
         type: 'problem';
     };
-    /**
-     * A family literal, which fires whatever the declared roles are — the question `exercised` asks
-     * is whether the rule RUNS here, and a probe built out of an undeclared role name would be
-     * defeated by a repo that happened to declare one spelled the same.
-     */
     probe(): Probe;
 };
 export default fontRolesOnly;

package/dist/rules/font-roles-only.js

@@ -1,6 +1,6 @@
 // src/rules/font-roles-only.ts
 import { requireOption } from "./lib/options.js";
-import { isModule, normalise } from "./lib/paths.js";
+import { isExempt, normalise } from "./lib/paths.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 import {
   arbitraryValuesOf,
@@ -11,38 +11,35 @@ import {
 var WEIGHT = /^\d+(?:\.\d+)?$/;
 var fontRolesOnly = {
   create(context) {
-    const { allow = [], exemptModules = [], prefix = "--font-", roles } = context.options?.[0] ?? {};
+    const { prefix = "--font-", roles, ...exempt } = context.options?.[0] ?? {};
     const declared = requireOption("font-roles-only", roles, "roles");
-    const filename = normalise(context.filename);
-    if (exemptModules.some((module) => isModule(filename, module)))
-      return {};
-    if (allow.some((path) => filename.includes(path)))
+    if (isExempt(normalise(context.filename), exempt))
       return {};
+    const judge = (value, node) => {
+      const variable = variableOf(value);
+      if (variable === undefined) {
+        context.report({ data: { value }, messageId: "familyLiteral", node });
+        return;
+      }
+      if (!variable.startsWith(prefix))
+        return;
+      const role = variable.slice(prefix.length);
+      if (!declared.includes(role)) {
+        context.report({ data: { role, value }, messageId: "undeclaredRole", node });
+      }
+    };
     return {
       JSXOpeningElement(node) {
-        const judge = (value) => {
-          const variable = variableOf(value);
-          if (variable === undefined) {
-            context.report({ data: { value }, messageId: "familyLiteral", node });
-            return;
-          }
-          if (!variable.startsWith(prefix))
-            return;
-          const role = variable.slice(prefix.length);
-          if (!declared.includes(role)) {
-            context.report({ data: { role, value }, messageId: "undeclaredRole", node });
-          }
-        };
         for (const { property, value } of styleEntriesOf(node)) {
           if (property === "fontFamily" || property === "font")
-            judge(value);
+            judge(value, node);
         }
         const className = classNameOf(node);
         if (className === undefined)
           return;
         for (const [utility, inner] of arbitraryValuesOf(className)) {
-          if (utility.replace(/^.*:/, "") === "font" && !WEIGHT.test(inner))
-            judge(inner);
+          if (utility === "font" && !WEIGHT.test(inner))
+            judge(inner, node);
         }
       }
     };

package/dist/rules/hermetic-e2e-no-wall-clock-waits.d.ts

@@ -0,0 +1,53 @@
+import { type RuleContextWithRawOptions } from './lib/context.js';
+import { type AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
+declare const hermeticE2eNoWallClockWaits: {
+    create(context: RuleContextWithRawOptions): {
+        CallExpression?: undefined;
+    } | {
+        CallExpression(node: AnyNode): void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            clockWait: string;
+            listResponseWait: string;
+        };
+        schema: {
+            additionalProperties: boolean;
+            properties: {
+                clockWaits: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                listEndpoints: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                networkWaits: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                specs: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+            };
+            type: 'object';
+        }[];
+        type: 'problem';
+    };
+    probe(options: readonly unknown[]): Probe;
+};
+export default hermeticE2eNoWallClockWaits;