openpond-sdk 0.9.9 → 0.11.0

package/dist/types/packages/sdk/src/connected-recorded-execution.d.ts

@@ -0,0 +1,690 @@
+import { z } from "zod";
+export declare const ConnectedRecordedExecutionRequestSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    name: z.ZodString;
+    projectId: z.ZodString;
+    dataset: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    caseIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const ConnectedRecordedSourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    snapshotHash: z.ZodString;
+    boundaryId: z.ZodString;
+    boundaryRevisionHash: z.ZodString;
+    inputHash: z.ZodString;
+    outputHash: z.ZodNullable<z.ZodString>;
+    task: z.ZodObject<{
+        id: z.ZodString;
+        clusterKey: z.ZodString;
+        split: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        policyVisibleContext: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        privilegedContextRef: z.ZodNullable<z.ZodString>;
+        artifactRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>>;
+        requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            mediaType: z.ZodString;
+            schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>>;
+            maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    taskHash: z.ZodString;
+}, z.core.$strict>;
+export declare const ConnectedRecordedExecutionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.connectedRecordedExecution.v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    request: z.ZodObject<{
+        operationId: z.ZodString;
+        name: z.ZodString;
+        projectId: z.ZodString;
+        dataset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        caseIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    manifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.experimentManifest.v1">;
+        id: z.ZodString;
+        name: z.ZodString;
+        teamId: z.ZodString;
+        operationId: z.ZodString;
+        maximumCostUsd: z.ZodNullable<z.ZodNumber>;
+        dataset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"model">;
+            modelId: z.ZodString;
+            configurationHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"harness">;
+            source: z.ZodObject<{
+                profileId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                definitionHash: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                environmentHash: z.ZodString;
+                externalDatasetBinding: z.ZodOptional<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                    dataset: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    packageHash: z.ZodString;
+                    profileId: z.ZodString;
+                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"profile">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"workflow">;
+                        workflowId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"skill">;
+                        skillPath: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent_action">;
+                        actionId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                    protectedProfileClosureHash: z.ZodString;
+                    recordedOrigin: z.ZodOptional<z.ZodObject<{
+                        execution: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        originalEvidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        members: z.ZodArray<z.ZodObject<{
+                            caseId: z.ZodString;
+                            seed: z.ZodString;
+                            fixtureId: z.ZodString;
+                            sourceId: z.ZodString;
+                            snapshotHash: z.ZodString;
+                            boundaryRevisionHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    gradingSource: z.ZodOptional<z.ZodObject<{
+                        pass: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        evidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>>;
+                    split: z.ZodEnum<{
+                        train: "train";
+                        validation: "validation";
+                        test: "test";
+                        frozen_eval: "frozen_eval";
+                    }>;
+                    population: z.ZodArray<z.ZodObject<{
+                        taskId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    evaluators: z.ZodArray<z.ZodObject<{
+                        release: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                        }, z.core.$strict>;
+                        feedbackKey: z.ZodString;
+                        configurationHash: z.ZodString;
+                        output: z.ZodEnum<{
+                            boolean: "boolean";
+                            score: "score";
+                            category: "category";
+                        }>;
+                        categories: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                    fieldMappingsHash: z.ZodString;
+                    fieldMappings: z.ZodArray<z.ZodObject<{
+                        graderId: z.ZodString;
+                        fields: z.ZodArray<z.ZodObject<{
+                            destination: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                            source: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            sourcePath: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    environmentHash: z.ZodString;
+                    privateDatasetClosureHash: z.ZodString;
+                    criterion: z.ZodObject<{
+                        minimumPassRate: z.ZodNumber;
+                        requireComplete: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                sourceCandidate: z.ZodOptional<z.ZodObject<{
+                    candidateId: z.ZodString;
+                    frozenRevision: z.ZodNumber;
+                    frozenHash: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    protectedClosureHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            model: z.ZodObject<{
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            source: z.ZodObject<{
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                agentSnapshot: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                sourcePackageHash: z.ZodString;
+            }, z.core.$strict>;
+            model: z.ZodObject<{
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fixture">;
+            configurationHash: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        execution: z.ZodOptional<z.ZodObject<{
+            packageHash: z.ZodString;
+            runtimeTargetHash: z.ZodString;
+            metricPolicyHash: z.ZodString;
+            compatibility: z.ZodOptional<z.ZodObject<{
+                protocol: z.ZodLiteral<"openpond.evaluation-execution.v1">;
+                targetKind: z.ZodEnum<{
+                    agent: "agent";
+                    model: "model";
+                    fixture: "fixture";
+                    harness: "harness";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            definition: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+            execution: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            scoringPassId: z.ZodNullable<z.ZodString>;
+            humanProjection: z.ZodOptional<z.ZodObject<{
+                originalManifest: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                selectionHash: z.ZodString;
+                rulesHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        evaluators: z.ZodArray<z.ZodObject<{
+            release: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>;
+            feedbackKey: z.ZodString;
+            configurationHash: z.ZodOptional<z.ZodString>;
+            output: z.ZodEnum<{
+                boolean: "boolean";
+                score: "score";
+                category: "category";
+            }>;
+            categories: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        population: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            seed: z.ZodString;
+            fixtureId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        snapshotHash: z.ZodString;
+        boundaryId: z.ZodString;
+        boundaryRevisionHash: z.ZodString;
+        inputHash: z.ZodString;
+        outputHash: z.ZodNullable<z.ZodString>;
+        task: z.ZodObject<{
+            id: z.ZodString;
+            clusterKey: z.ZodString;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            policyVisibleContext: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            privilegedContextRef: z.ZodNullable<z.ZodString>;
+            artifactRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>>;
+            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                mediaType: z.ZodString;
+                schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>>;
+                maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strict>>>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        taskHash: z.ZodString;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ConnectedRecordedExecution = z.infer<typeof ConnectedRecordedExecutionSchema>;
+export declare function verifyConnectedRecordedExecution(raw: unknown): {
+    schemaVersion: "openpond.connectedRecordedExecution.v1";
+    id: string;
+    teamId: string;
+    ownerUserId: string;
+    request: {
+        operationId: string;
+        name: string;
+        projectId: string;
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        caseIds: string[];
+    };
+    manifest: {
+        schemaVersion: "openpond.experimentManifest.v1";
+        id: string;
+        name: string;
+        teamId: string;
+        operationId: string;
+        maximumCostUsd: number | null;
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        target: {
+            kind: "model";
+            modelId: string;
+            configurationHash: string;
+        } | {
+            kind: "harness";
+            source: {
+                profileId: string;
+                sourceRevision: string;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                catalogHash: string;
+                definitionId: string;
+                definitionHash: string;
+                target: {
+                    kind: "profile";
+                } | {
+                    kind: "workflow";
+                    workflowId: string;
+                } | {
+                    kind: "skill";
+                    skillPath: string;
+                } | {
+                    kind: "agent_action";
+                    actionId: string;
+                };
+                environmentHash: string;
+                externalDatasetBinding?: {
+                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                    dataset: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    packageHash: string;
+                    profileId: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    declaredProfileCatalogHash: string | null;
+                    protectedProfileClosureHash: string;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                    population: {
+                        taskId: string;
+                        seed: string;
+                        fixtureId: string | null;
+                    }[];
+                    evaluators: {
+                        release: {
+                            id: string;
+                            contentHash: string;
+                            revision: string | number;
+                        };
+                        feedbackKey: string;
+                        configurationHash: string;
+                        output: "boolean" | "score" | "category";
+                        categories: string[];
+                    }[];
+                    fieldMappingsHash: string;
+                    fieldMappings: {
+                        graderId: string;
+                        fields: {
+                            destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            path: string[];
+                            source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            sourcePath: string[];
+                        }[];
+                    }[];
+                    environmentHash: string;
+                    privateDatasetClosureHash: string;
+                    criterion: {
+                        minimumPassRate: number;
+                        requireComplete: boolean;
+                    };
+                    contentHash: string;
+                    recordedOrigin?: {
+                        execution: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        originalEvidence: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        members: {
+                            caseId: string;
+                            seed: string;
+                            fixtureId: string;
+                            sourceId: string;
+                            snapshotHash: string;
+                            boundaryRevisionHash: string;
+                        }[];
+                    } | undefined;
+                    gradingSource?: {
+                        pass: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        evidence: {
+                            id: string;
+                            contentHash: string;
+                        };
+                    } | undefined;
+                } | undefined;
+                sourceCandidate?: {
+                    candidateId: string;
+                    frozenRevision: number;
+                    frozenHash: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    protectedClosureHash: string;
+                } | undefined;
+            };
+            model: {
+                modelId: string;
+                configurationHash: string;
+            };
+        } | {
+            kind: "agent";
+            source: {
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                agentSnapshot: {
+                    id: string;
+                    contentHash: string;
+                };
+                sourcePackageHash: string;
+            };
+            model: {
+                modelId: string;
+                configurationHash: string;
+            };
+        } | {
+            kind: "fixture";
+            configurationHash: string;
+        };
+        evaluators: {
+            release: {
+                id: string;
+                contentHash: string;
+                revision: string | number;
+            };
+            feedbackKey: string;
+            output: "boolean" | "score" | "category";
+            categories: string[];
+            configurationHash?: string | undefined;
+        }[];
+        population: {
+            caseId: string;
+            seed: string;
+            fixtureId: string | null;
+        }[];
+        createdAt: string;
+        contentHash: string;
+        execution?: {
+            packageHash: string;
+            runtimeTargetHash: string;
+            metricPolicyHash: string;
+            compatibility?: {
+                protocol: "openpond.evaluation-execution.v1";
+                targetKind: "harness" | "fixture" | "model" | "agent";
+            } | undefined;
+        } | undefined;
+        lineage?: {
+            definition: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            execution: {
+                id: string;
+                contentHash: string;
+            };
+            scoringPassId: string | null;
+            humanProjection?: {
+                originalManifest: {
+                    id: string;
+                    contentHash: string;
+                };
+                selectionHash: string;
+                rulesHash: string;
+            } | undefined;
+        } | undefined;
+    };
+    sources: {
+        id: string;
+        snapshotHash: string;
+        boundaryId: string;
+        boundaryRevisionHash: string;
+        inputHash: string;
+        outputHash: string | null;
+        task: {
+            id: string;
+            clusterKey: string;
+            split: "train" | "validation" | "test" | "frozen_eval";
+            input: Record<string, unknown>;
+            expectedOutput: Record<string, unknown> | null;
+            policyVisibleContext: Record<string, unknown>;
+            privilegedContextRef: string | null;
+            artifactRefs: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            tags: string[];
+            requiredOutputs?: {
+                path: string;
+                mediaType: string;
+                schemaRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                } | null;
+                maxBytes: number | null;
+                metadata: Record<string, unknown>;
+            }[] | undefined;
+        };
+        taskHash: string;
+    }[];
+    contentHash: string;
+};
+export declare const ConnectedRecordedListRequestSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const ConnectedRecordedSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodString;
+    name: z.ZodString;
+    dataset: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    manifestHash: z.ZodString;
+    contentHash: z.ZodString;
+    caseCount: z.ZodNumber;
+    createdAt: z.ZodString;
+}, z.core.$strict>;
+export declare const ConnectedRecordedListSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodString;
+        name: z.ZodString;
+        dataset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        manifestHash: z.ZodString;
+        contentHash: z.ZodString;
+        caseCount: z.ZodNumber;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+//# sourceMappingURL=connected-recorded-execution.d.ts.map

package/dist/types/packages/sdk/src/connected-recorded-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connected-recorded-execution.d.ts","sourceRoot":"","sources":["../../../../../src/connected-recorded-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,uCAAuC;;;;;;;;;;kBAIlD,CAAC;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACU,CAAC;AACrD,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE0F,CAAC;AACxI,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAC1F,wBAAgB,gCAAgC,CAAC,GAAG,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW5D;AAED,eAAO,MAAM,kCAAkC;;;;kBAA6H,CAAC;AAC7K,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;kBAE0F,CAAC;AACtI,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;kBAAuH,CAAC"}