@kensio/yulin 1.20.0 → 1.20.2

package/dist/service/lambda/function/environment/sim-lambda-host-backed-variables.js

@@ -0,0 +1,49 @@
+import { simProcessEnvironment } from "../../../../util/process/sim-process-environment.js";
+/**
+ * The environment of a function that declares no variables of its own.
+ *
+ * It is the host process environment with the AWS-provided runtime variables
+ * laid over it. The host variables are read for each invocation rather than
+ * merged once, so a variable the test process sets between two invocations
+ * reaches the second of them.
+ *
+ * What the handler itself wrote is kept and laid over both, which is the warm
+ * execution environment semantics a function declaring variables gets from
+ * reusing one object. A name the handler wrote and the host also sets is the
+ * handler's, until the function is replaced.
+ */
+export class SimLambdaHostBackedVariables {
+    written = new Map();
+    /**
+     * Run function code with these variables as its process.env.
+     */
+    async runWith(functionVariables, run) {
+        const merged = {
+            ...simProcessEnvironment.definedHostVariables(),
+            ...functionVariables,
+            ...Object.fromEntries(this.written),
+        };
+        const variables = { ...merged };
+        try {
+            return await simProcessEnvironment.run(variables, run);
+        }
+        finally {
+            this.recordWrites(merged, variables);
+        }
+    }
+    /**
+     * Keep what the handler wrote for the next invocation.
+     *
+     * A name the handler removed is left out. The next invocation reads it from
+     * the host process again, the way a name it never touched is read.
+     */
+    recordWrites(merged, variables) {
+        const before = new Map(Object.entries(merged));
+        for (const [name, value] of Object.entries(variables)) {
+            if (before.get(name) !== value) {
+                this.written.set(name, value);
+            }
+        }
+    }
+}
+//# sourceMappingURL=sim-lambda-host-backed-variables.js.map

package/dist/service/lambda/function/environment/sim-lambda-host-backed-variables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-host-backed-variables.js","sourceRoot":"","sources":["../../../../../src/service/lambda/function/environment/sim-lambda-host-backed-variables.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAE5F;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,4BAA4B;IACtB,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAErD;;OAEG;IACH,KAAK,CAAC,OAAO,CACX,iBAAyC,EACzC,GAAqB;QAErB,MAAM,MAAM,GAAG;YACb,GAAG,qBAAqB,CAAC,oBAAoB,EAAE;YAC/C,GAAG,iBAAiB;YACpB,GAAG,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC;SACpC,CAAC;QACF,MAAM,SAAS,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC;QAEhC,IAAI,CAAC;YACH,OAAO,MAAM,qBAAqB,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QACzD,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,YAAY,CAClB,MAA8B,EAC9B,SAAiC;QAEjC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAE/C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YACtD,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,KAAK,EAAE,CAAC;gBAC/B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAChC,CAAC;QACH,CAAC;IACH,CAAC;CACF"}

package/dist/service/lambda/function/environment/sim-lambda-runtime-variables.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The function details the AWS-provided runtime environment variables are
+ * built from.
+ */
+export interface SimLambdaEnvironmentDetails {
+    readonly functionName: string;
+    readonly regionName: string;
+    readonly memorySizeMb: number;
+}
+/**
+ * The AWS-like standard runtime environment variables a function runs with.
+ *
+ * Real Lambda provides these to every invocation, whatever the function's
+ * configuration declares, and an AWS SDK client built in the handler reads
+ * its Region and its credentials from them.
+ */
+export declare function simLambdaRuntimeVariables(details: SimLambdaEnvironmentDetails): Record<string, string>;
+//# sourceMappingURL=sim-lambda-runtime-variables.d.ts.map

package/dist/service/lambda/function/environment/sim-lambda-runtime-variables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-runtime-variables.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/function/environment/sim-lambda-runtime-variables.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,2BAA2B,GACnC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcxB"}

package/dist/service/lambda/function/environment/sim-lambda-runtime-variables.js

@@ -0,0 +1,23 @@
+import { simLambdaExecutionCredentials } from "./sim-lambda-execution-credentials.js";
+/**
+ * The AWS-like standard runtime environment variables a function runs with.
+ *
+ * Real Lambda provides these to every invocation, whatever the function's
+ * configuration declares, and an AWS SDK client built in the handler reads
+ * its Region and its credentials from them.
+ */
+export function simLambdaRuntimeVariables(details) {
+    const { functionName, regionName, memorySizeMb } = details;
+    // Built from entries rather than an object literal because AWS environment
+    // variable names are not code identifier names, and the project's naming
+    // rules treat object literal keys as if they were.
+    return Object.fromEntries([
+        ["AWS_REGION", regionName],
+        ["AWS_DEFAULT_REGION", regionName],
+        ["AWS_LAMBDA_FUNCTION_NAME", functionName],
+        ["AWS_LAMBDA_FUNCTION_MEMORY_SIZE", String(memorySizeMb)],
+        ["AWS_LAMBDA_FUNCTION_VERSION", "$LATEST"],
+        ...simLambdaExecutionCredentials,
+    ]);
+}
+//# sourceMappingURL=sim-lambda-runtime-variables.js.map

package/dist/service/lambda/function/environment/sim-lambda-runtime-variables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-runtime-variables.js","sourceRoot":"","sources":["../../../../../src/service/lambda/function/environment/sim-lambda-runtime-variables.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,uCAAuC,CAAC;AAYtF;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB,CACvC,OAAoC;IAEpC,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC;IAE3D,2EAA2E;IAC3E,yEAAyE;IACzE,mDAAmD;IACnD,OAAO,MAAM,CAAC,WAAW,CAAC;QACxB,CAAC,YAAY,EAAE,UAAU,CAAC;QAC1B,CAAC,oBAAoB,EAAE,UAAU,CAAC;QAClC,CAAC,0BAA0B,EAAE,YAAY,CAAC;QAC1C,CAAC,iCAAiC,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC;QACzD,CAAC,6BAA6B,EAAE,SAAS,CAAC;QAC1C,GAAG,6BAA6B;KACjC,CAAC,CAAC;AACL,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-choice-group-test.d.ts

@@ -0,0 +1,32 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesChoiceTest } from "./sim-states-choice-test.js";
+/**
+ * An `And`, which holds where every test it carries does.
+ */
+export declare class SimStatesAllTest implements SimStatesChoiceTest {
+    #private;
+    constructor(tests: readonly SimStatesChoiceTest[]);
+    /**
+     * The tests are made in the order they were written, and stop at the first
+     * one that does not hold. That is what lets an `IsPresent` guard a
+     * comparison of the same field further along the same `And`.
+     */
+    holds(input: JSONValue): boolean;
+}
+/**
+ * An `Or`, which holds where any test it carries does.
+ */
+export declare class SimStatesAnyTest implements SimStatesChoiceTest {
+    #private;
+    constructor(tests: readonly SimStatesChoiceTest[]);
+    holds(input: JSONValue): boolean;
+}
+/**
+ * A `Not`, which holds where the test it carries does not.
+ */
+export declare class SimStatesNotTest implements SimStatesChoiceTest {
+    #private;
+    constructor(test: SimStatesChoiceTest);
+    holds(input: JSONValue): boolean;
+}
+//# sourceMappingURL=sim-states-choice-group-test.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-choice-group-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-group-test.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-group-test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;GAEG;AACH,qBAAa,gBAAiB,YAAW,mBAAmB;;IAG1D,YAAY,KAAK,EAAE,SAAS,mBAAmB,EAAE,EAEhD;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAE/B;CACF;AAED;;GAEG;AACH,qBAAa,gBAAiB,YAAW,mBAAmB;;IAG1D,YAAY,KAAK,EAAE,SAAS,mBAAmB,EAAE,EAEhD;IAED,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAE/B;CACF;AAED;;GAEG;AACH,qBAAa,gBAAiB,YAAW,mBAAmB;;IAG1D,YAAY,IAAI,EAAE,mBAAmB,EAEpC;IAED,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAE/B;CACF"}

package/dist/service/stepfunctions/choice/sim-states-choice-group-test.js

@@ -0,0 +1,42 @@
+/**
+ * An `And`, which holds where every test it carries does.
+ */
+export class SimStatesAllTest {
+    #tests;
+    constructor(tests) {
+        this.#tests = tests;
+    }
+    /**
+     * The tests are made in the order they were written, and stop at the first
+     * one that does not hold. That is what lets an `IsPresent` guard a
+     * comparison of the same field further along the same `And`.
+     */
+    holds(input) {
+        return this.#tests.every((test) => test.holds(input));
+    }
+}
+/**
+ * An `Or`, which holds where any test it carries does.
+ */
+export class SimStatesAnyTest {
+    #tests;
+    constructor(tests) {
+        this.#tests = tests;
+    }
+    holds(input) {
+        return this.#tests.some((test) => test.holds(input));
+    }
+}
+/**
+ * A `Not`, which holds where the test it carries does not.
+ */
+export class SimStatesNotTest {
+    #test;
+    constructor(test) {
+        this.#test = test;
+    }
+    holds(input) {
+        return !this.#test.holds(input);
+    }
+}
+//# sourceMappingURL=sim-states-choice-group-test.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-group-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-group-test.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-group-test.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,OAAO,gBAAgB;IAClB,MAAM,CAAiC;IAEhD,YAAY,KAAqC;QAC/C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAgB;QACpB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACxD,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,gBAAgB;IAClB,MAAM,CAAiC;IAEhD,YAAY,KAAqC;QAC/C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,KAAgB;QACpB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACvD,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,gBAAgB;IAClB,KAAK,CAAsB;IAEpC,YAAY,IAAyB;QACnC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,KAAgB;QACpB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-choice-operand.d.ts

@@ -0,0 +1,29 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesPathSegment } from "../data/sim-states-path-segment.js";
+/**
+ * The value one side of a comparison is made against.
+ */
+export interface SimStatesChoiceOperand {
+    valueIn(input: JSONValue): JSONValue;
+}
+/**
+ * An operand the definition wrote out, as in `NumericEquals: 3`.
+ */
+export declare class SimStatesLiteralOperand implements SimStatesChoiceOperand {
+    #private;
+    constructor(value: JSONValue);
+    valueIn(): JSONValue;
+}
+/**
+ * An operand read from the state's input, as in `NumericEqualsPath: "$.want"`.
+ *
+ * A path selecting nothing fails the execution. The comparison has no value to
+ * make, and answering false would read as a rule that was tested and did not
+ * match.
+ */
+export declare class SimStatesPathOperand implements SimStatesChoiceOperand {
+    #private;
+    constructor(path: string, segments: readonly SimStatesPathSegment[]);
+    valueIn(input: JSONValue): JSONValue;
+}
+//# sourceMappingURL=sim-states-choice-operand.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-choice-operand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-operand.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-operand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAG/E;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAAC;CACtC;AAED;;GAEG;AACH,qBAAa,uBAAwB,YAAW,sBAAsB;;IAGpE,YAAY,KAAK,EAAE,SAAS,EAE3B;IAED,OAAO,IAAI,SAAS,CAEnB;CACF;AAED;;;;;;GAMG;AACH,qBAAa,oBAAqB,YAAW,sBAAsB;;IAIjE,YAAY,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EAGlE;IAED,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAWnC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-choice-operand.js

@@ -0,0 +1,38 @@
+import { selectSimStatesPath } from "../data/sim-states-path-segment.js";
+import { SimStatesRuntimeFailure } from "../error/sim-step-functions.error.js";
+/**
+ * An operand the definition wrote out, as in `NumericEquals: 3`.
+ */
+export class SimStatesLiteralOperand {
+    #value;
+    constructor(value) {
+        this.#value = value;
+    }
+    valueIn() {
+        return this.#value;
+    }
+}
+/**
+ * An operand read from the state's input, as in `NumericEqualsPath: "$.want"`.
+ *
+ * A path selecting nothing fails the execution. The comparison has no value to
+ * make, and answering false would read as a rule that was tested and did not
+ * match.
+ */
+export class SimStatesPathOperand {
+    #path;
+    #segments;
+    constructor(path, segments) {
+        this.#path = path;
+        this.#segments = segments;
+    }
+    valueIn(input) {
+        const value = selectSimStatesPath(input, this.#segments);
+        if (value === undefined) {
+            throw new SimStatesRuntimeFailure(`A Choice rule reads its operand from ${this.#path}, which selects ` +
+                "nothing in the state's input.");
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=sim-states-choice-operand.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-operand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-operand.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-operand.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAEzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAS/E;;GAEG;AACH,MAAM,OAAO,uBAAuB;IACzB,MAAM,CAAY;IAE3B,YAAY,KAAgB;QAC1B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,OAAO,oBAAoB;IACtB,KAAK,CAAS;IACd,SAAS,CAAkC;IAEpD,YAAY,IAAY,EAAE,QAAyC;QACjE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC5B,CAAC;IAED,OAAO,CAAC,KAAgB;QACtB,MAAM,KAAK,GAAG,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAEzD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,uBAAuB,CAC/B,wCAAwC,IAAI,CAAC,KAAK,kBAAkB;gBAClE,+BAA+B,CAClC,CAAC;QACJ,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-choice-parse.d.ts

@@ -0,0 +1,15 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import { SimStatesChoiceRule } from "./sim-states-choice-rule.js";
+/**
+ * Read a `Choice` state's rules, refusing anything this cannot test.
+ *
+ * The rules are read when the state machine is created, so a `Choice` state
+ * that runs is one whose comparators, paths and operand types are already
+ * known to be good.
+ */
+export declare function parseSimStatesChoices(stateName: string, state: Record<string, JSONValue>): readonly SimStatesChoiceRule[];
+/**
+ * Check a `Choice` state's `Default`, the state it goes to when no rule holds.
+ */
+export declare function checkSimStatesChoiceDefault(stateName: string, state: Record<string, JSONValue>): void;
+//# sourceMappingURL=sim-states-choice-parse.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-choice-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-parse.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAIlE;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAC/B,SAAS,mBAAmB,EAAE,CAWhC;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAC/B,IAAI,CAYN"}

package/dist/service/stepfunctions/choice/sim-states-choice-parse.js

@@ -0,0 +1,44 @@
+import { SimStatesInvalidDefinition } from "../error/sim-step-functions.error.js";
+import { SimStatesChoiceRule } from "./sim-states-choice-rule.js";
+import { asSimStatesRuleRecord } from "./sim-states-choice-rule-record.js";
+import { parseSimStatesChoiceTest } from "./sim-states-choice-test-parse.js";
+/**
+ * Read a `Choice` state's rules, refusing anything this cannot test.
+ *
+ * The rules are read when the state machine is created, so a `Choice` state
+ * that runs is one whose comparators, paths and operand types are already
+ * known to be good.
+ */
+export function parseSimStatesChoices(stateName, state) {
+    const declared = state["Choices"];
+    if (!Array.isArray(declared) || declared.length === 0) {
+        throw new SimStatesInvalidDefinition(`The Choice state ${stateName} carries no Choices. A Choice state ` +
+            "needs at least one rule saying where the execution goes.");
+    }
+    return declared.map((rule) => parseRule(stateName, rule));
+}
+/**
+ * Check a `Choice` state's `Default`, the state it goes to when no rule holds.
+ */
+export function checkSimStatesChoiceDefault(stateName, state) {
+    const fallback = state["Default"];
+    if (fallback === undefined) {
+        return;
+    }
+    if (typeof fallback !== "string") {
+        throw new SimStatesInvalidDefinition(`The Choice state ${stateName} has a Default that is not a state name.`);
+    }
+}
+/**
+ * Read one top-level rule, which names where a match goes next.
+ */
+function parseRule(stateName, rule) {
+    const record = asSimStatesRuleRecord(stateName, rule);
+    const next = record["Next"];
+    if (typeof next !== "string") {
+        throw new SimStatesInvalidDefinition(`A rule in the Choice state ${stateName} has no Next naming the state ` +
+            "a match goes to.");
+    }
+    return new SimStatesChoiceRule(parseSimStatesChoiceTest(stateName, record), next);
+}
+//# sourceMappingURL=sim-states-choice-parse.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-parse.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-parse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,SAAiB,EACjB,KAAgC;IAEhC,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;IAElC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtD,MAAM,IAAI,0BAA0B,CAClC,oBAAoB,SAAS,sCAAsC;YACjE,0DAA0D,CAC7D,CAAC;IACJ,CAAC;IAED,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,2BAA2B,CACzC,SAAiB,EACjB,KAAgC;IAEhC,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;IAElC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO;IACT,CAAC;IAED,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,MAAM,IAAI,0BAA0B,CAClC,oBAAoB,SAAS,0CAA0C,CACxE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,SAAS,CAAC,SAAiB,EAAE,IAAe;IACnD,MAAM,MAAM,GAAG,qBAAqB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACtD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IAE5B,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,MAAM,IAAI,0BAA0B,CAClC,8BAA8B,SAAS,gCAAgC;YACrE,kBAAkB,CACrB,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,mBAAmB,CAC5B,wBAAwB,CAAC,SAAS,EAAE,MAAM,CAAC,EAC3C,IAAI,CACL,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-choice-rule-record.d.ts

@@ -0,0 +1,10 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+/**
+ * Find the field naming what a rule tests.
+ */
+export declare function readSimStatesRuleOperator(stateName: string, record: Record<string, JSONValue>): string;
+/**
+ * Read one rule as the object it has to be.
+ */
+export declare function asSimStatesRuleRecord(stateName: string, rule: JSONValue | undefined): Record<string, JSONValue>;
+//# sourceMappingURL=sim-states-choice-rule-record.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-choice-rule-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-rule-record.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-rule-record.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAOlE;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAChC,MAAM,CAsBR;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,SAAS,GAAG,SAAS,GAC1B,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAQ3B"}

package/dist/service/stepfunctions/choice/sim-states-choice-rule-record.js

@@ -0,0 +1,31 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+import { SimStatesInvalidDefinition } from "../error/sim-step-functions.error.js";
+// What a rule carries besides the test it makes.
+const ruleFields = new Set(["Variable", "Next", "Comment"]);
+/**
+ * Find the field naming what a rule tests.
+ */
+export function readSimStatesRuleOperator(stateName, record) {
+    const operators = Object.keys(record).filter((field) => !ruleFields.has(field));
+    const [operator] = operators;
+    if (operator === undefined) {
+        throw new SimStatesInvalidDefinition(`A rule in the Choice state ${stateName} tests nothing. A rule carries ` +
+            "one comparator, or an And, an Or or a Not.");
+    }
+    if (operators.length > 1) {
+        throw new SimStatesInvalidDefinition(`A rule in the Choice state ${stateName} carries ` +
+            `${operators.join(", ")}. A rule carries one comparator, or an And, ` +
+            "an Or or a Not.");
+    }
+    return operator;
+}
+/**
+ * Read one rule as the object it has to be.
+ */
+export function asSimStatesRuleRecord(stateName, rule) {
+    if (!isRecord(rule)) {
+        throw new SimStatesInvalidDefinition(`A rule in the Choice state ${stateName} is not an object.`);
+    }
+    return rule;
+}
+//# sourceMappingURL=sim-states-choice-rule-record.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-rule-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-rule-record.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-rule-record.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAC9D,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAElF,iDAAiD;AACjD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AAE5D;;GAEG;AACH,MAAM,UAAU,yBAAyB,CACvC,SAAiB,EACjB,MAAiC;IAEjC,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAC1C,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAClC,CAAC;IACF,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IAE7B,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,0BAA0B,CAClC,8BAA8B,SAAS,iCAAiC;YACtE,4CAA4C,CAC/C,CAAC;IACJ,CAAC;IAED,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,0BAA0B,CAClC,8BAA8B,SAAS,WAAW;YAChD,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,8CAA8C;YACrE,iBAAiB,CACpB,CAAC;IACJ,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,qBAAqB,CACnC,SAAiB,EACjB,IAA2B;IAE3B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,0BAA0B,CAClC,8BAA8B,SAAS,oBAAoB,CAC5D,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-choice-rule.d.ts

@@ -0,0 +1,15 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesChoiceTest } from "./sim-states-choice-test.js";
+/**
+ * One rule in a `Choice` state's `Choices`, and the state a match moves to.
+ */
+export declare class SimStatesChoiceRule {
+    #private;
+    readonly next: string;
+    constructor(test: SimStatesChoiceTest, next: string);
+    /**
+     * Whether this rule's test holds for the state's effective input.
+     */
+    matches(input: JSONValue): boolean;
+}
+//# sourceMappingURL=sim-states-choice-rule.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-choice-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-rule.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;GAEG;AACH,qBAAa,mBAAmB;;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAItB,YAAY,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAGlD;IAED;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAEjC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-choice-rule.js

@@ -0,0 +1,18 @@
+/**
+ * One rule in a `Choice` state's `Choices`, and the state a match moves to.
+ */
+export class SimStatesChoiceRule {
+    next;
+    #test;
+    constructor(test, next) {
+        this.#test = test;
+        this.next = next;
+    }
+    /**
+     * Whether this rule's test holds for the state's effective input.
+     */
+    matches(input) {
+        return this.#test.holds(input);
+    }
+}
+//# sourceMappingURL=sim-states-choice-rule.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-rule.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-rule.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,OAAO,mBAAmB;IACrB,IAAI,CAAS;IAEb,KAAK,CAAsB;IAEpC,YAAY,IAAyB,EAAE,IAAY;QACjD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,KAAgB;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-choice-test-parse.d.ts

@@ -0,0 +1,7 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesChoiceTest } from "./sim-states-choice-test.js";
+/**
+ * Read the one test a rule makes.
+ */
+export declare function parseSimStatesChoiceTest(stateName: string, record: Record<string, JSONValue>): SimStatesChoiceTest;
+//# sourceMappingURL=sim-states-choice-test-parse.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-choice-test-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-test-parse.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-test-parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAWlE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AA8BvE;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAChC,mBAAmB,CA2BrB"}

package/dist/service/stepfunctions/choice/sim-states-choice-test-parse.js

@@ -0,0 +1,72 @@
+import { SimStatesInvalidDefinition } from "../error/sim-step-functions.error.js";
+import { SimStatesAllTest, SimStatesAnyTest, SimStatesNotTest, } from "./sim-states-choice-group-test.js";
+import { asSimStatesRuleRecord, readSimStatesRuleOperator, } from "./sim-states-choice-rule-record.js";
+import { parseSimStatesComparisonTest } from "./sim-states-comparison-parse.js";
+import { findSimStatesComparison } from "./sim-states-comparisons.js";
+const booleanOperators = new Set(["And", "Or", "Not"]);
+/**
+ * Read a rule nested inside an `And`, an `Or` or a `Not`.
+ *
+ * Only a top-level rule says where the execution goes, so a nested one
+ * carrying `Next` is refused rather than quietly ignored.
+ */
+function parseNestedTest(stateName, operator, rule) {
+    const record = asSimStatesRuleRecord(stateName, rule);
+    if (Object.hasOwn(record, "Next")) {
+        throw new SimStatesInvalidDefinition(`A rule inside the ${operator} of the Choice state ${stateName} ` +
+            "carries Next. Only the rule at the top of a Choices entry says " +
+            "where the execution goes.");
+    }
+    return parseSimStatesChoiceTest(stateName, record);
+}
+/**
+ * Read the one test a rule makes.
+ */
+export function parseSimStatesChoiceTest(stateName, record) {
+    const operator = readSimStatesRuleOperator(stateName, record);
+    // The operator was read off this record's own keys, so it holds a value.
+    // oxlint-disable-next-line security/detect-object-injection
+    const written = record[operator];
+    if (booleanOperators.has(operator)) {
+        checkNoVariable(stateName, operator, record);
+        return parseBooleanTest(stateName, operator, written);
+    }
+    const comparison = findSimStatesComparison(operator);
+    if (comparison === undefined) {
+        throw new SimStatesInvalidDefinition(`A rule in the Choice state ${stateName} tests with ${operator}, which ` +
+            "is not a comparator Amazon States Language defines.");
+    }
+    return parseSimStatesComparisonTest({
+        stateName,
+        record,
+        comparison,
+        written,
+    });
+}
+/**
+ * Read an `And`, an `Or` or a `Not` and the rules it holds.
+ */
+function parseBooleanTest(stateName, operator, written) {
+    if (operator === "Not") {
+        return new SimStatesNotTest(parseNestedTest(stateName, operator, written));
+    }
+    if (!Array.isArray(written) || written.length === 0) {
+        throw new SimStatesInvalidDefinition(`The ${operator} in a rule of the Choice state ${stateName} is not a ` +
+            "non-empty array of rules.");
+    }
+    const tests = written.map((nested) => parseNestedTest(stateName, operator, nested));
+    if (operator === "And") {
+        return new SimStatesAllTest(tests);
+    }
+    return new SimStatesAnyTest(tests);
+}
+/**
+ * An `And`, an `Or` or a `Not` tests rules rather than a value of its own.
+ */
+function checkNoVariable(stateName, operator, record) {
+    if (Object.hasOwn(record, "Variable")) {
+        throw new SimStatesInvalidDefinition(`The ${operator} in a rule of the Choice state ${stateName} carries a ` +
+            "Variable. The rules it holds carry their own.");
+    }
+}
+//# sourceMappingURL=sim-states-choice-test-parse.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-test-parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-test-parse.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-test-parse.ts"],"names":[],"mappings":"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"}

package/dist/service/stepfunctions/choice/sim-states-choice-test.d.ts

@@ -0,0 +1,33 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesPathSegment } from "../data/sim-states-path-segment.js";
+import type { SimStatesChoiceOperand } from "./sim-states-choice-operand.js";
+import type { SimStatesComparison } from "./sim-states-comparison.js";
+/**
+ * One test a `Choice` rule makes against the state's input.
+ */
+export interface SimStatesChoiceTest {
+    holds(input: JSONValue): boolean;
+}
+interface SimStatesVariableTestProperties {
+    readonly path: string;
+    readonly segments: readonly SimStatesPathSegment[];
+    readonly comparison: SimStatesComparison;
+    readonly operand: SimStatesChoiceOperand;
+}
+/**
+ * A comparison of the value at a `Variable` path against an operand.
+ */
+export declare class SimStatesVariableTest implements SimStatesChoiceTest {
+    #private;
+    constructor(properties: SimStatesVariableTestProperties);
+    /**
+     * Compare, failing the execution where the field being compared is absent.
+     *
+     * Real Step Functions fails a `Choice` state whose `Variable` selects
+     * nothing, which is why `IsPresent` exists. The data-test comparators answer
+     * for an absent field of their own accord.
+     */
+    holds(input: JSONValue): boolean;
+}
+export {};
+//# sourceMappingURL=sim-states-choice-test.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-choice-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-test.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC;CAClC;AAED,UAAU,+BAA+B;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACnD,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC;CAC1C;AAED;;GAEG;AACH,qBAAa,qBAAsB,YAAW,mBAAmB;;IAM/D,YAAY,UAAU,EAAE,+BAA+B,EAKtD;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAY/B;CACF"}

package/dist/service/stepfunctions/choice/sim-states-choice-test.js

@@ -0,0 +1,34 @@
+import { selectSimStatesPath } from "../data/sim-states-path-segment.js";
+import { SimStatesRuntimeFailure } from "../error/sim-step-functions.error.js";
+/**
+ * A comparison of the value at a `Variable` path against an operand.
+ */
+export class SimStatesVariableTest {
+    #path;
+    #segments;
+    #comparison;
+    #operand;
+    constructor(properties) {
+        this.#path = properties.path;
+        this.#segments = properties.segments;
+        this.#comparison = properties.comparison;
+        this.#operand = properties.operand;
+    }
+    /**
+     * Compare, failing the execution where the field being compared is absent.
+     *
+     * Real Step Functions fails a `Choice` state whose `Variable` selects
+     * nothing, which is why `IsPresent` exists. The data-test comparators answer
+     * for an absent field of their own accord.
+     */
+    holds(input) {
+        const value = selectSimStatesPath(input, this.#segments);
+        if (value === undefined && this.#comparison.needsValue) {
+            throw new SimStatesRuntimeFailure(`A Choice rule compares ${this.#path} with ` +
+                `${this.#comparison.name}, and the state's input holds nothing ` +
+                "there. Test it with IsPresent first where it may be absent.");
+        }
+        return this.#comparison.holds(value, this.#operand.valueIn(input));
+    }
+}
+//# sourceMappingURL=sim-states-choice-test.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-test.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-test.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAEzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAkB/E;;GAEG;AACH,MAAM,OAAO,qBAAqB;IACvB,KAAK,CAAS;IACd,SAAS,CAAkC;IAC3C,WAAW,CAAsB;IACjC,QAAQ,CAAyB;IAE1C,YAAY,UAA2C;QACrD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC;QACrC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAgB;QACpB,MAAM,KAAK,GAAG,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAEzD,IAAI,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;YACvD,MAAM,IAAI,uBAAuB,CAC/B,0BAA0B,IAAI,CAAC,KAAK,QAAQ;gBAC1C,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,wCAAwC;gBAChE,6DAA6D,CAChE,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IACrE,CAAC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-comparison-families.d.ts

@@ -0,0 +1,26 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import { SimStatesComparison, type SimStatesOperandType } from "./sim-states-comparison.js";
+/**
+ * Read a JSON value as a string, or as nothing where it is not one.
+ */
+export declare function readString(value: JSONValue | undefined): string | undefined;
+/**
+ * Read a JSON value as a number, or as nothing where it is not one.
+ */
+export declare function readNumber(value: JSONValue | undefined): number | undefined;
+/**
+ * The five ordering comparators over one JSON type.
+ *
+ * A value of the wrong type on either side answers false rather than failing.
+ * `StringEquals` against a number is a comparison that does not hold, and a
+ * rule the input does not match is the ordinary case in a `Choice` state.
+ */
+export declare function orderedComparisons<T>(prefix: string, operandType: SimStatesOperandType, read: (value: JSONValue | undefined) => T | undefined): SimStatesComparison[];
+/**
+ * One data-test comparator, such as `IsString`.
+ *
+ * These are the comparators that answer for a `Variable` selecting nothing,
+ * which is what makes `IsPresent` usable as the first test in an `And`.
+ */
+export declare function dataTest(name: string, describes: (variable: JSONValue | undefined) => boolean): SimStatesComparison;
+//# sourceMappingURL=sim-states-comparison-families.d.ts.map