@archastro/sdk 0.15.0 → 0.16.0

package/dist/types/scripts.d.ts

@@ -0,0 +1,800 @@
+import { z } from "zod";
+/** Schema for ArchAstro script editor metadata */
+export interface ScriptLanguageSpec {
+    /** Builtin function docs */
+    builtins: Record<string, unknown>[];
+    /** Language keywords */
+    keywords: string[];
+    /** Monaco language identifier */
+    languageId: string;
+    /** Importable namespace docs */
+    namespaces: Record<string, unknown>[];
+    /** Language operators */
+    operators: string[];
+    /** Names that cannot be rebound */
+    reservedNames?: string[] | undefined;
+    /** Editor snippet templates */
+    snippets?: Record<string, unknown>[] | undefined;
+    /** Special symbols such as JSONPath root/current */
+    specialIdentifiers?: Record<string, unknown>[] | undefined;
+    /** Named type definitions (event interfaces, etc.) with fields */
+    typeDefinitions?: Record<string, unknown>[] | undefined;
+    /** Type-system primitives, generics, annotations, inference, and runtime-check guidance */
+    typeSystem?: Record<string, unknown> | undefined;
+    /** Schema version */
+    version: number;
+}
+/** Runtime validator for {@link ScriptLanguageSpec}. */
+export declare const scriptLanguageSpecSchema: z.ZodObject<{
+    /** Builtin function docs */
+    builtins: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>, "many">;
+    /** Language keywords */
+    keywords: z.ZodArray<z.ZodString, "many">;
+    /** Monaco language identifier */
+    languageId: z.ZodString;
+    /** Importable namespace docs */
+    namespaces: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>, "many">;
+    /** Language operators */
+    operators: z.ZodArray<z.ZodString, "many">;
+    /** Names that cannot be rebound */
+    reservedNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Editor snippet templates */
+    snippets: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>, "many">>;
+    /** Special symbols such as JSONPath root/current */
+    specialIdentifiers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>, "many">>;
+    /** Named type definitions (event interfaces, etc.) with fields */
+    typeDefinitions: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>, "many">>;
+    /** Type-system primitives, generics, annotations, inference, and runtime-check guidance */
+    typeSystem: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>>;
+    /** Schema version */
+    version: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    builtins: Record<string, {} | null>[];
+    keywords: string[];
+    languageId: string;
+    namespaces: Record<string, {} | null>[];
+    operators: string[];
+    reservedNames?: string[] | undefined;
+    snippets?: Record<string, {} | null>[] | undefined;
+    specialIdentifiers?: Record<string, {} | null>[] | undefined;
+    typeDefinitions?: Record<string, {} | null>[] | undefined;
+    typeSystem?: Record<string, {} | null> | undefined;
+}, {
+    version: number;
+    builtins: Record<string, {} | null>[];
+    keywords: string[];
+    languageId: string;
+    namespaces: Record<string, {} | null>[];
+    operators: string[];
+    reservedNames?: string[] | undefined;
+    snippets?: Record<string, {} | null>[] | undefined;
+    specialIdentifiers?: Record<string, {} | null>[] | undefined;
+    typeDefinitions?: Record<string, {} | null>[] | undefined;
+    typeSystem?: Record<string, {} | null> | undefined;
+}>;
+/** Schema for the result of executing a script in the editor */
+export interface ScriptRunResult {
+    /** Error message when script execution failed */
+    error?: string | undefined;
+    /** Structured diagnostics with position info for editor markers (severity, message, line, column, end_line, end_column) */
+    findings?: Record<string, unknown>[] | undefined;
+    /** Output lines from println calls, each with :line (source line number), :text, and optional :values */
+    output?: Record<string, unknown>[] | undefined;
+    /** The evaluated JSON-safe result (null when execution failed) */
+    result?: unknown | undefined;
+}
+/** Runtime validator for {@link ScriptRunResult}. */
+export declare const scriptRunResultSchema: z.ZodObject<{
+    /** Error message when script execution failed */
+    error: z.ZodOptional<z.ZodString>;
+    /** Structured diagnostics with position info for editor markers (severity, message, line, column, end_line, end_column) */
+    findings: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>, "many">>;
+    /** Output lines from println calls, each with :line (source line number), :text, and optional :values */
+    output: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>, "many">>;
+    /** The evaluated JSON-safe result (null when execution failed) */
+    result: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+}, "strip", z.ZodTypeAny, {
+    error?: string | undefined;
+    result?: {} | null | undefined;
+    output?: Record<string, {} | null>[] | undefined;
+    findings?: Record<string, {} | null>[] | undefined;
+}, {
+    error?: string | undefined;
+    result?: {} | null | undefined;
+    output?: Record<string, {} | null>[] | undefined;
+    findings?: Record<string, {} | null>[] | undefined;
+}>;
+/**
+ * One `test.expect(...).<matcher>` call from a ScriptTest run.
+ * Matchers never raise (the script language has no exceptions) — each call
+ * emits a structured assertion entry that the test runner harvests into the
+ * per-test report. Pass/fail is captured on `:pass`; `:expected` and
+ * `:actual` carry the matcher's inputs for diff rendering.
+ */
+export interface ScriptTestAssertion {
+    /** Actual value the matcher was called with — any JSON-safe value */
+    actual?: unknown | undefined;
+    /** Outer-to-inner describe path when the assertion fired */
+    describe?: string[] | undefined;
+    /** Expected value (or arguments to the matcher) — any JSON-safe value: scalar, map, or list */
+    expected?: unknown | undefined;
+    /** Name of the enclosing `test.it(...)` block */
+    it?: string | undefined;
+    /** Output entry kind, always `"assertion"` for this schema */
+    kind?: string | undefined;
+    /** Source line of the `expect(...)` call */
+    line?: number | undefined;
+    /** Matcher name (toEqual, toBe, toBeOk, toBeError, toContain, toMatch, toHaveLength) */
+    matcher?: string | undefined;
+    /** True when the matcher succeeded */
+    pass: boolean;
+}
+/** Runtime validator for {@link ScriptTestAssertion}. */
+export declare const scriptTestAssertionSchema: z.ZodObject<{
+    /** Actual value the matcher was called with — any JSON-safe value */
+    actual: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+    /** Outer-to-inner describe path when the assertion fired */
+    describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Expected value (or arguments to the matcher) — any JSON-safe value: scalar, map, or list */
+    expected: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+    /** Name of the enclosing `test.it(...)` block */
+    it: z.ZodOptional<z.ZodString>;
+    /** Output entry kind, always `"assertion"` for this schema */
+    kind: z.ZodOptional<z.ZodString>;
+    /** Source line of the `expect(...)` call */
+    line: z.ZodOptional<z.ZodNumber>;
+    /** Matcher name (toEqual, toBe, toBeOk, toBeError, toContain, toMatch, toHaveLength) */
+    matcher: z.ZodOptional<z.ZodString>;
+    /** True when the matcher succeeded */
+    pass: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    pass: boolean;
+    kind?: string | undefined;
+    expected?: {} | null | undefined;
+    actual?: {} | null | undefined;
+    describe?: string[] | undefined;
+    it?: string | undefined;
+    line?: number | undefined;
+    matcher?: string | undefined;
+}, {
+    pass: boolean;
+    kind?: string | undefined;
+    expected?: {} | null | undefined;
+    actual?: {} | null | undefined;
+    describe?: string[] | undefined;
+    it?: string | undefined;
+    line?: number | undefined;
+    matcher?: string | undefined;
+}>;
+/**
+ * One `test.it(...)` block from a ScriptTest run.
+ * Built by the harvester from the raw output entries — pairs the case's
+ * metadata with the assertions it produced and any runtime error that
+ * aborted the body. An `it` block that emits zero assertions is treated
+ * as a failure (`pass: false`) so silent mistakes don't pass quietly.
+ */
+export interface ScriptTestCase {
+    /** Every `test.expect(...)` matcher that ran inside this case */
+    assertions?: ScriptTestAssertion[] | undefined;
+    /** Outer-to-inner describe path enclosing this case */
+    describe?: string[] | undefined;
+    /** Runtime error that aborted the body of this `it` block, when one occurred */
+    error?: string | undefined;
+    /** The name passed to `test.it(...)` */
+    name: string;
+    /** True when the case has at least one assertion and every assertion passed */
+    pass: boolean;
+}
+/** Runtime validator for {@link ScriptTestCase}. */
+export declare const scriptTestCaseSchema: z.ZodObject<{
+    /** Every `test.expect(...)` matcher that ran inside this case */
+    assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Actual value the matcher was called with — any JSON-safe value */
+        actual: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+        /** Outer-to-inner describe path when the assertion fired */
+        describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Expected value (or arguments to the matcher) — any JSON-safe value: scalar, map, or list */
+        expected: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+        /** Name of the enclosing `test.it(...)` block */
+        it: z.ZodOptional<z.ZodString>;
+        /** Output entry kind, always `"assertion"` for this schema */
+        kind: z.ZodOptional<z.ZodString>;
+        /** Source line of the `expect(...)` call */
+        line: z.ZodOptional<z.ZodNumber>;
+        /** Matcher name (toEqual, toBe, toBeOk, toBeError, toContain, toMatch, toHaveLength) */
+        matcher: z.ZodOptional<z.ZodString>;
+        /** True when the matcher succeeded */
+        pass: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        pass: boolean;
+        kind?: string | undefined;
+        expected?: {} | null | undefined;
+        actual?: {} | null | undefined;
+        describe?: string[] | undefined;
+        it?: string | undefined;
+        line?: number | undefined;
+        matcher?: string | undefined;
+    }, {
+        pass: boolean;
+        kind?: string | undefined;
+        expected?: {} | null | undefined;
+        actual?: {} | null | undefined;
+        describe?: string[] | undefined;
+        it?: string | undefined;
+        line?: number | undefined;
+        matcher?: string | undefined;
+    }>, "many">>;
+    /** Outer-to-inner describe path enclosing this case */
+    describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Runtime error that aborted the body of this `it` block, when one occurred */
+    error: z.ZodOptional<z.ZodString>;
+    /** The name passed to `test.it(...)` */
+    name: z.ZodString;
+    /** True when the case has at least one assertion and every assertion passed */
+    pass: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    pass: boolean;
+    error?: string | undefined;
+    describe?: string[] | undefined;
+    assertions?: {
+        pass: boolean;
+        kind?: string | undefined;
+        expected?: {} | null | undefined;
+        actual?: {} | null | undefined;
+        describe?: string[] | undefined;
+        it?: string | undefined;
+        line?: number | undefined;
+        matcher?: string | undefined;
+    }[] | undefined;
+}, {
+    name: string;
+    pass: boolean;
+    error?: string | undefined;
+    describe?: string[] | undefined;
+    assertions?: {
+        pass: boolean;
+        kind?: string | undefined;
+        expected?: {} | null | undefined;
+        actual?: {} | null | undefined;
+        describe?: string[] | undefined;
+        it?: string | undefined;
+        line?: number | undefined;
+        matcher?: string | undefined;
+    }[] | undefined;
+}>;
+/**
+ * One println/log entry interleaved with a ScriptTest run.
+ * After the test harvester filters out test-control entries (`it`,
+ * `assertion`, `it_error`), only `println` and `log.<level>` calls remain
+ * in the report's `output` field. Both shapes share `text`/`values`/`line`
+ * (line is auto-annotated by the evaluator post-call); `level` and
+ * `timestamp` are only present on `log.*` entries.
+ */
+export interface ScriptTestOutputEntry {
+    /** Log level (`debug`, `info`, `warn`, `error`) — present on log.* entries only */
+    level?: string | undefined;
+    /** Source line of the println/log call */
+    line?: number | undefined;
+    /** Joined text representation of the args */
+    text: string;
+    /** UTC timestamp — present on log.* entries only */
+    timestamp?: string | undefined;
+    /** Original args coerced to JSON-safe values — mixed scalars, maps, and lists since the call sites accept arbitrary expressions */
+    values?: unknown[] | undefined;
+}
+/** Runtime validator for {@link ScriptTestOutputEntry}. */
+export declare const scriptTestOutputEntrySchema: z.ZodObject<{
+    /** Log level (`debug`, `info`, `warn`, `error`) — present on log.* entries only */
+    level: z.ZodOptional<z.ZodString>;
+    /** Source line of the println/log call */
+    line: z.ZodOptional<z.ZodNumber>;
+    /** Joined text representation of the args */
+    text: z.ZodString;
+    /** UTC timestamp — present on log.* entries only */
+    timestamp: z.ZodOptional<z.ZodString>;
+    /** Original args coerced to JSON-safe values — mixed scalars, maps, and lists since the call sites accept arbitrary expressions */
+    values: z.ZodOptional<z.ZodArray<z.ZodType<{} | null, z.ZodTypeDef, {} | null>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    level?: string | undefined;
+    values?: ({} | null)[] | undefined;
+    line?: number | undefined;
+    timestamp?: string | undefined;
+}, {
+    text: string;
+    level?: string | undefined;
+    values?: ({} | null)[] | undefined;
+    line?: number | undefined;
+    timestamp?: string | undefined;
+}>;
+/**
+ * One `test.describe(...)` group from a ScriptTest run.
+ * Suites are derived from the unique describe paths the harvester sees, so
+ * there's no synthetic "ungrouped" suite — `it` blocks emitted outside any
+ * `describe` show up in the top-level `tests` array on the parent report
+ * instead.
+ */
+export interface ScriptTestSuite {
+    /** Outer-to-inner describe path identifying this suite */
+    describe: string[];
+    /** Human-readable suite name (`describe` path joined by ` > `) */
+    name: string;
+    /** Every `test.it(...)` case run inside this describe */
+    tests?: ScriptTestCase[] | undefined;
+}
+/** Runtime validator for {@link ScriptTestSuite}. */
+export declare const scriptTestSuiteSchema: z.ZodObject<{
+    /** Outer-to-inner describe path identifying this suite */
+    describe: z.ZodArray<z.ZodString, "many">;
+    /** Human-readable suite name (`describe` path joined by ` > `) */
+    name: z.ZodString;
+    /** Every `test.it(...)` case run inside this describe */
+    tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Every `test.expect(...)` matcher that ran inside this case */
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /** Actual value the matcher was called with — any JSON-safe value */
+            actual: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+            /** Outer-to-inner describe path when the assertion fired */
+            describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Expected value (or arguments to the matcher) — any JSON-safe value: scalar, map, or list */
+            expected: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+            /** Name of the enclosing `test.it(...)` block */
+            it: z.ZodOptional<z.ZodString>;
+            /** Output entry kind, always `"assertion"` for this schema */
+            kind: z.ZodOptional<z.ZodString>;
+            /** Source line of the `expect(...)` call */
+            line: z.ZodOptional<z.ZodNumber>;
+            /** Matcher name (toEqual, toBe, toBeOk, toBeError, toContain, toMatch, toHaveLength) */
+            matcher: z.ZodOptional<z.ZodString>;
+            /** True when the matcher succeeded */
+            pass: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }, {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }>, "many">>;
+        /** Outer-to-inner describe path enclosing this case */
+        describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Runtime error that aborted the body of this `it` block, when one occurred */
+        error: z.ZodOptional<z.ZodString>;
+        /** The name passed to `test.it(...)` */
+        name: z.ZodString;
+        /** True when the case has at least one assertion and every assertion passed */
+        pass: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        pass: boolean;
+        error?: string | undefined;
+        describe?: string[] | undefined;
+        assertions?: {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }[] | undefined;
+    }, {
+        name: string;
+        pass: boolean;
+        error?: string | undefined;
+        describe?: string[] | undefined;
+        assertions?: {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }[] | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    describe: string[];
+    tests?: {
+        name: string;
+        pass: boolean;
+        error?: string | undefined;
+        describe?: string[] | undefined;
+        assertions?: {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+}, {
+    name: string;
+    describe: string[];
+    tests?: {
+        name: string;
+        pass: boolean;
+        error?: string | undefined;
+        describe?: string[] | undefined;
+        assertions?: {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+}>;
+/** Schema for the result of running a ScriptTest */
+export interface ScriptTestRunResult {
+    /** Total number of `test.expect(...)` matcher calls that ran */
+    assertion_count?: number | undefined;
+    /** Top-level error message when a runtime error fired outside any `it` block (parse/tokenize errors return 422 instead) */
+    error?: string | undefined;
+    /** Structured diagnostics with position info for editor markers when the run errored before any tests could run */
+    findings?: Record<string, unknown>[] | undefined;
+    /** Non-test output entries (println, log.*) interleaved during the run */
+    output?: ScriptTestOutputEntry[] | undefined;
+    /** True when every test in every suite passed */
+    passed: boolean;
+    /** One entry per describe path */
+    suites?: ScriptTestSuite[] | undefined;
+    /** Flat list of every `it` that ran, each with assertions and pass flag */
+    tests?: ScriptTestCase[] | undefined;
+}
+/** Runtime validator for {@link ScriptTestRunResult}. */
+export declare const scriptTestRunResultSchema: z.ZodObject<{
+    /** Total number of `test.expect(...)` matcher calls that ran */
+    assertion_count: z.ZodOptional<z.ZodNumber>;
+    /** Top-level error message when a runtime error fired outside any `it` block (parse/tokenize errors return 422 instead) */
+    error: z.ZodOptional<z.ZodString>;
+    /** Structured diagnostics with position info for editor markers when the run errored before any tests could run */
+    findings: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<{} | null, z.ZodTypeDef, {} | null>>, "many">>;
+    /** Non-test output entries (println, log.*) interleaved during the run */
+    output: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Log level (`debug`, `info`, `warn`, `error`) — present on log.* entries only */
+        level: z.ZodOptional<z.ZodString>;
+        /** Source line of the println/log call */
+        line: z.ZodOptional<z.ZodNumber>;
+        /** Joined text representation of the args */
+        text: z.ZodString;
+        /** UTC timestamp — present on log.* entries only */
+        timestamp: z.ZodOptional<z.ZodString>;
+        /** Original args coerced to JSON-safe values — mixed scalars, maps, and lists since the call sites accept arbitrary expressions */
+        values: z.ZodOptional<z.ZodArray<z.ZodType<{} | null, z.ZodTypeDef, {} | null>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        level?: string | undefined;
+        values?: ({} | null)[] | undefined;
+        line?: number | undefined;
+        timestamp?: string | undefined;
+    }, {
+        text: string;
+        level?: string | undefined;
+        values?: ({} | null)[] | undefined;
+        line?: number | undefined;
+        timestamp?: string | undefined;
+    }>, "many">>;
+    /** True when every test in every suite passed */
+    passed: z.ZodBoolean;
+    /** One entry per describe path */
+    suites: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Outer-to-inner describe path identifying this suite */
+        describe: z.ZodArray<z.ZodString, "many">;
+        /** Human-readable suite name (`describe` path joined by ` > `) */
+        name: z.ZodString;
+        /** Every `test.it(...)` case run inside this describe */
+        tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /** Every `test.expect(...)` matcher that ran inside this case */
+            assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                /** Actual value the matcher was called with — any JSON-safe value */
+                actual: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+                /** Outer-to-inner describe path when the assertion fired */
+                describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                /** Expected value (or arguments to the matcher) — any JSON-safe value: scalar, map, or list */
+                expected: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+                /** Name of the enclosing `test.it(...)` block */
+                it: z.ZodOptional<z.ZodString>;
+                /** Output entry kind, always `"assertion"` for this schema */
+                kind: z.ZodOptional<z.ZodString>;
+                /** Source line of the `expect(...)` call */
+                line: z.ZodOptional<z.ZodNumber>;
+                /** Matcher name (toEqual, toBe, toBeOk, toBeError, toContain, toMatch, toHaveLength) */
+                matcher: z.ZodOptional<z.ZodString>;
+                /** True when the matcher succeeded */
+                pass: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                pass: boolean;
+                kind?: string | undefined;
+                expected?: {} | null | undefined;
+                actual?: {} | null | undefined;
+                describe?: string[] | undefined;
+                it?: string | undefined;
+                line?: number | undefined;
+                matcher?: string | undefined;
+            }, {
+                pass: boolean;
+                kind?: string | undefined;
+                expected?: {} | null | undefined;
+                actual?: {} | null | undefined;
+                describe?: string[] | undefined;
+                it?: string | undefined;
+                line?: number | undefined;
+                matcher?: string | undefined;
+            }>, "many">>;
+            /** Outer-to-inner describe path enclosing this case */
+            describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Runtime error that aborted the body of this `it` block, when one occurred */
+            error: z.ZodOptional<z.ZodString>;
+            /** The name passed to `test.it(...)` */
+            name: z.ZodString;
+            /** True when the case has at least one assertion and every assertion passed */
+            pass: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            pass: boolean;
+            error?: string | undefined;
+            describe?: string[] | undefined;
+            assertions?: {
+                pass: boolean;
+                kind?: string | undefined;
+                expected?: {} | null | undefined;
+                actual?: {} | null | undefined;
+                describe?: string[] | undefined;
+                it?: string | undefined;
+                line?: number | undefined;
+                matcher?: string | undefined;
+            }[] | undefined;
+        }, {
+            name: string;
+            pass: boolean;
+            error?: string | undefined;
+            describe?: string[] | undefined;
+            assertions?: {
+                pass: boolean;
+                kind?: string | undefined;
+                expected?: {} | null | undefined;
+                actual?: {} | null | undefined;
+                describe?: string[] | undefined;
+                it?: string | undefined;
+                line?: number | undefined;
+                matcher?: string | undefined;
+            }[] | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        describe: string[];
+        tests?: {
+            name: string;
+            pass: boolean;
+            error?: string | undefined;
+            describe?: string[] | undefined;
+            assertions?: {
+                pass: boolean;
+                kind?: string | undefined;
+                expected?: {} | null | undefined;
+                actual?: {} | null | undefined;
+                describe?: string[] | undefined;
+                it?: string | undefined;
+                line?: number | undefined;
+                matcher?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+    }, {
+        name: string;
+        describe: string[];
+        tests?: {
+            name: string;
+            pass: boolean;
+            error?: string | undefined;
+            describe?: string[] | undefined;
+            assertions?: {
+                pass: boolean;
+                kind?: string | undefined;
+                expected?: {} | null | undefined;
+                actual?: {} | null | undefined;
+                describe?: string[] | undefined;
+                it?: string | undefined;
+                line?: number | undefined;
+                matcher?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+    }>, "many">>;
+    /** Flat list of every `it` that ran, each with assertions and pass flag */
+    tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Every `test.expect(...)` matcher that ran inside this case */
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /** Actual value the matcher was called with — any JSON-safe value */
+            actual: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+            /** Outer-to-inner describe path when the assertion fired */
+            describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Expected value (or arguments to the matcher) — any JSON-safe value: scalar, map, or list */
+            expected: z.ZodOptional<z.ZodType<{} | null, z.ZodTypeDef, {} | null>>;
+            /** Name of the enclosing `test.it(...)` block */
+            it: z.ZodOptional<z.ZodString>;
+            /** Output entry kind, always `"assertion"` for this schema */
+            kind: z.ZodOptional<z.ZodString>;
+            /** Source line of the `expect(...)` call */
+            line: z.ZodOptional<z.ZodNumber>;
+            /** Matcher name (toEqual, toBe, toBeOk, toBeError, toContain, toMatch, toHaveLength) */
+            matcher: z.ZodOptional<z.ZodString>;
+            /** True when the matcher succeeded */
+            pass: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }, {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }>, "many">>;
+        /** Outer-to-inner describe path enclosing this case */
+        describe: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Runtime error that aborted the body of this `it` block, when one occurred */
+        error: z.ZodOptional<z.ZodString>;
+        /** The name passed to `test.it(...)` */
+        name: z.ZodString;
+        /** True when the case has at least one assertion and every assertion passed */
+        pass: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        pass: boolean;
+        error?: string | undefined;
+        describe?: string[] | undefined;
+        assertions?: {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }[] | undefined;
+    }, {
+        name: string;
+        pass: boolean;
+        error?: string | undefined;
+        describe?: string[] | undefined;
+        assertions?: {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }[] | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    passed: boolean;
+    error?: string | undefined;
+    output?: {
+        text: string;
+        level?: string | undefined;
+        values?: ({} | null)[] | undefined;
+        line?: number | undefined;
+        timestamp?: string | undefined;
+    }[] | undefined;
+    findings?: Record<string, {} | null>[] | undefined;
+    tests?: {
+        name: string;
+        pass: boolean;
+        error?: string | undefined;
+        describe?: string[] | undefined;
+        assertions?: {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    assertion_count?: number | undefined;
+    suites?: {
+        name: string;
+        describe: string[];
+        tests?: {
+            name: string;
+            pass: boolean;
+            error?: string | undefined;
+            describe?: string[] | undefined;
+            assertions?: {
+                pass: boolean;
+                kind?: string | undefined;
+                expected?: {} | null | undefined;
+                actual?: {} | null | undefined;
+                describe?: string[] | undefined;
+                it?: string | undefined;
+                line?: number | undefined;
+                matcher?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+    }[] | undefined;
+}, {
+    passed: boolean;
+    error?: string | undefined;
+    output?: {
+        text: string;
+        level?: string | undefined;
+        values?: ({} | null)[] | undefined;
+        line?: number | undefined;
+        timestamp?: string | undefined;
+    }[] | undefined;
+    findings?: Record<string, {} | null>[] | undefined;
+    tests?: {
+        name: string;
+        pass: boolean;
+        error?: string | undefined;
+        describe?: string[] | undefined;
+        assertions?: {
+            pass: boolean;
+            kind?: string | undefined;
+            expected?: {} | null | undefined;
+            actual?: {} | null | undefined;
+            describe?: string[] | undefined;
+            it?: string | undefined;
+            line?: number | undefined;
+            matcher?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    assertion_count?: number | undefined;
+    suites?: {
+        name: string;
+        describe: string[];
+        tests?: {
+            name: string;
+            pass: boolean;
+            error?: string | undefined;
+            describe?: string[] | undefined;
+            assertions?: {
+                pass: boolean;
+                kind?: string | undefined;
+                expected?: {} | null | undefined;
+                actual?: {} | null | undefined;
+                describe?: string[] | undefined;
+                it?: string | undefined;
+                line?: number | undefined;
+                matcher?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+    }[] | undefined;
+}>;
+//# sourceMappingURL=scripts.d.ts.map