rea-agents
    Preparing search index...

    Variable replayEvidenceSchemaConst

    replayEvidenceSchema: ZodObject<
        {
            analysis_profile: ZodOptional<
                ZodObject<
                    {
                        digest: ZodString;
                        parameters: ZodRecord<ZodString, ZodJSONSchema>;
                        provider: ZodObject<
                            { id: ZodString; name: ZodString; version: ZodString },
                            $strip,
                        >;
                        provider_profile_schema_version: ZodNumber;
                        schema_version: ZodLiteral<1>;
                    },
                    $strip,
                >,
            >;
            authority: ZodEnum<
                {
                    "analyst-inference": "analyst-inference";
                    "controlled-replay": "controlled-replay";
                    "external-service": "external-service";
                    "historical-reference": "historical-reference";
                    "shipped-artifact": "shipped-artifact";
                },
            >;
            confidence: ZodEnum<
                { derived: "derived"; inferred: "inferred"; observed: "observed" },
            >;
            environment: ZodNullable<
                ZodObject<
                    {
                        architecture: ZodString;
                        id: ZodString;
                        isolation: ZodEnum<
                            {
                                container: "container";
                                none: "none";
                                process: "process";
                                "virtual-machine": "virtual-machine";
                            },
                        >;
                        platform: ZodString;
                    },
                    $strip,
                >,
            >;
            evidence_id: ZodString;
            evidence_links: ZodArray<ZodString>;
            limitations: ZodArray<ZodString>;
            locations: ZodArray<
                ZodDiscriminatedUnion<
                    [
                        ZodObject<
                            { address: ZodString; kind: ZodLiteral<"address"> },
                            $strip,
                        >,
                        ZodObject<
                            {
                                end: ZodString;
                                kind: ZodLiteral<"address-range">;
                                start: ZodString;
                            },
                            $strip,
                        >,
                        ZodObject<
                            { kind: ZodLiteral<"artifact-path">; path: ZodString },
                            $strip,
                        >,
                        ZodObject<
                            { kind: ZodLiteral<"file-offset">; offset: ZodNumber },
                            $strip,
                        >,
                        ZodObject<
                            {
                                end: ZodNumber;
                                kind: ZodLiteral<"file-offset-range">;
                                start: ZodNumber;
                            },
                            $strip,
                        >,
                    ],
                    "kind",
                >,
            >;
            normalized_result: ZodObject<
                {
                    cleanup: ZodObject<
                        {
                            residual_resources: ZodArray<ZodString>;
                            state: ZodEnum<{ complete: "complete"; incomplete: "incomplete" }>;
                        },
                        $strict,
                    >;
                    comparison: ZodOptional<
                        ZodArray<
                            ZodObject<
                                {
                                    case_id: ZodString;
                                    left_index: ZodNumber;
                                    right_index: ZodNumber;
                                    status: ZodEnum<
                                        { changed: "changed"; equal: "equal"; unknown: "unknown" },
                                    >;
                                },
                                $strict,
                            >,
                        >,
                    >;
                    limitations: ZodArray<ZodString>;
                    outcomes: ZodArray<
                        ZodObject<
                            {
                                case_id: ZodString;
                                exception: ZodOptional<
                                    ZodObject<
                                        {
                                            message: ZodString;
                                            name: ZodString;
                                            stack: ZodNullable<(...)>;
                                        },
                                        $strict,
                                    >,
                                >;
                                input_sha256: ZodString;
                                outcome: ZodEnum<
                                    {
                                        cancelled: "cancelled";
                                        crash: "crash";
                                        denied: "denied";
                                        exception: "exception";
                                        oom: "oom";
                                        protocol_error: "protocol_error";
                                        return: "return";
                                        serialization_error: "serialization_error";
                                        timeout: "timeout";
                                    },
                                >;
                                output_sha256: ZodNullable<ZodString>;
                                truncated: ZodBoolean;
                                value: ZodOptional<ZodJSONSchema>;
                            },
                            $strict,
                        >,
                    >;
                    plan_digest: ZodString;
                    reproducer: ZodNullable<
                        ZodDiscriminatedUnion<
                            [
                                ZodObject<
                                    {
                                        path: ZodString;
                                        sha256: ZodString;
                                        state: ZodLiteral<"written">;
                                    },
                                    $strict,
                                >,
                                ZodObject<
                                    {
                                        error: ZodString;
                                        path: ZodString;
                                        state: ZodLiteral<"failed">;
                                    },
                                    $strict,
                                >,
                            ],
                            "state",
                        >,
                    >;
                    schema_version: ZodLiteral<1>;
                    stderr: ZodString;
                    termination: ZodEnum<
                        {
                            cancelled: "cancelled";
                            completed: "completed";
                            crash: "crash";
                            oom: "oom";
                            protocol_error: "protocol_error";
                            timeout: "timeout";
                        },
                    >;
                },
                $strict,
            >;
            operation: ZodString;
            parameters: ZodRecord<ZodString, ZodJSONSchema>;
            predicate_type: ZodString;
            provider: ZodObject<
                { id: ZodString; name: ZodString; version: ZodNullable<ZodString> },
                $strip,
            >;
            raw_result: ZodNullable<ZodJSONSchema>;
            schema_version: ZodLiteral<2>;
            subject: ZodNullable<
                ZodObject<
                    {
                        architecture: ZodNullable<
                            ZodEnum<
                                { arm: "arm"; arm64: "arm64"; x86: "x86"; x86_64: "x86_64" },
                            >,
                        >;
                        digest: ZodObject<{ sha256: ZodString }, $strip>;
                        format: ZodEnum<
                            {
                                "analysis-database": "analysis-database";
                                apk: "apk";
                                asar: "asar";
                                directory: "directory";
                                dmg: "dmg";
                                elf: "elf";
                                entitlements: "entitlements";
                                file: "file";
                                hopper: "hopper";
                                ipa: "ipa";
                                javascript: "javascript";
                                "javascript-bundle": "javascript-bundle";
                                "mach-o": "mach-o";
                                "mach-o-universal": "mach-o-universal";
                                pe: "pe";
                                pkg: "pkg";
                                plist: "plist";
                                "source-map": "source-map";
                                unknown: "unknown";
                                zip: "zip";
                            },
                        >;
                        local_path: ZodString;
                        name: ZodString;
                    },
                    $strip,
                >,
            >;
        },
        $strict,
    > = ...