openpond-sdk 0.12.13 → 0.12.15

package/dist/types/packages/sdk/src/managed-modification-executions.d.ts

@@ -0,0 +1,1470 @@
+import { z } from "zod";
+import { type ManagedModificationCompile } from "./managed-modification-compilation.js";
+export * from "./managed-modification-compilation.js";
+/** Customer read projection. Capture availability is independent of execution
+ * cleanup and funding settlement; this read grants no dispatch authority. */
+export declare const ManagedModificationExecutionContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedModificationExecution.v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    method: z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>;
+    revision: z.ZodNumber;
+    sourceContentHash: z.ZodString;
+    plan: z.ZodObject<{
+        contentHash: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        maximumSpendUsd: z.ZodNullable<z.ZodString>;
+        computePrice: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            warmReuseSeconds: z.ZodLiteral<300>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceRequest.v1">;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        startingProfile: z.ZodOptional<z.ZodObject<{
+            modelProjectId: z.ZodString;
+            versionHash: z.ZodString;
+            publication: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            profileHash: z.ZodString;
+            variantId: z.ZodString;
+        }, z.core.$strict>>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            tokenIds: z.ZodArray<z.ZodNumber>;
+            attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        }, z.core.$strict>>;
+        variants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            profile: z.ZodNullable<z.ZodLazy<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronSteeringProfile.v1">;
+                model: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+                    modelId: z.ZodString;
+                    revision: z.ZodString;
+                    configHash: z.ZodString;
+                    weightsHash: z.ZodString;
+                    tokenizerHash: z.ZodString;
+                    weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+                    architecture: z.ZodLiteral<"dense_decoder">;
+                    dtype: z.ZodEnum<{
+                        bfloat16: "bfloat16";
+                        float16: "float16";
+                        float32: "float32";
+                    }>;
+                    quantization: z.ZodLiteral<"none">;
+                    adapter: z.ZodNull;
+                    hiddenSize: z.ZodNumber;
+                    intermediateSizes: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>;
+                hook: z.ZodLiteral<"mlp.down_proj.input">;
+                operation: z.ZodLiteral<"add">;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+                    statistic: z.ZodLiteral<"midpoint_median_fp32">;
+                    sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"fixed_residual_reference">;
+                    calibration: z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>], "mode">;
+                tokenScope: z.ZodObject<{
+                    phase: z.ZodEnum<{
+                        decode_only: "decode_only";
+                        prompt_and_decode: "prompt_and_decode";
+                        prompt_only: "prompt_only";
+                    }>;
+                    positions: z.ZodEnum<{
+                        after_position_zero: "after_position_zero";
+                        all_non_padding: "all_non_padding";
+                    }>;
+                }, z.core.$strict>;
+                entries: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                    dose: z.ZodNumber;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        capture: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            neurons: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+        maxNewTokens: z.ZodNumber;
+        eosTokenIds: z.ZodArray<z.ZodNumber>;
+        maximumCapturedValues: z.ZodNumber;
+        maximumForwardTokenWork: z.ZodNumber;
+        maximumDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    sourceForm: z.ZodOptional<z.ZodObject<{
+        baseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        startingProfile: z.ZodOptional<z.ZodObject<{
+            modelProjectId: z.ZodString;
+            versionHash: z.ZodString;
+            publication: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            profileHash: z.ZodString;
+        }, z.core.$strict>>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+        coordinates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            layer: z.ZodString;
+            neuron: z.ZodString;
+            dose: z.ZodString;
+        }, z.core.$strict>>;
+        doseMultipliers: z.ZodString;
+        normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+            statistic: z.ZodLiteral<"midpoint_median_fp32">;
+            sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"fixed_residual_reference">;
+            calibration: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "mode">;
+        tokenScope: z.ZodObject<{
+            phase: z.ZodEnum<{
+                decode_only: "decode_only";
+                prompt_and_decode: "prompt_and_decode";
+                prompt_only: "prompt_only";
+            }>;
+            positions: z.ZodEnum<{
+                after_position_zero: "after_position_zero";
+                all_non_padding: "all_non_padding";
+            }>;
+        }, z.core.$strict>;
+        maxNewTokens: z.ZodString;
+        maximumCapturedValues: z.ZodString;
+        maximumForwardTokenWork: z.ZodString;
+        maximumDurationSeconds: z.ZodString;
+        maximumSpendUsd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceResult.v1">;
+        requestHash: z.ZodString;
+        modelHash: z.ZodString;
+        runtime: z.ZodObject<{
+            implementation: z.ZodLiteral<"torch_dense_serial_reference_v1">;
+            implementationHash: z.ZodString;
+            torchVersion: z.ZodString;
+            device: z.ZodString;
+        }, z.core.$strict>;
+        outcomes: z.ZodArray<z.ZodObject<{
+            promptId: z.ZodString;
+            variantId: z.ZodString;
+            profileHash: z.ZodNullable<z.ZodString>;
+            generatedTokenIds: z.ZodArray<z.ZodNumber>;
+            forwardTokenWork: z.ZodNumber;
+            calibration: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                median: z.ZodNumber;
+                sampleCount: z.ZodNumber;
+                columnNorms: z.ZodArray<z.ZodObject<{
+                    neuron: z.ZodNumber;
+                    norm: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            durationMs: z.ZodNumber;
+            captureCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        captures: z.ZodArray<z.ZodObject<{
+            promptId: z.ZodString;
+            variantId: z.ZodString;
+            layer: z.ZodNumber;
+            neuron: z.ZodNumber;
+            tokenIndex: z.ZodNumber;
+            tokenId: z.ZodNumber;
+            before: z.ZodNumber;
+            after: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    resultRecordedAt: z.ZodNullable<z.ZodISODateTime>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const ManagedModificationExecutionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedModificationExecution.v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    method: z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>;
+    revision: z.ZodNumber;
+    sourceContentHash: z.ZodString;
+    plan: z.ZodObject<{
+        contentHash: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        maximumSpendUsd: z.ZodNullable<z.ZodString>;
+        computePrice: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            warmReuseSeconds: z.ZodLiteral<300>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceRequest.v1">;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        startingProfile: z.ZodOptional<z.ZodObject<{
+            modelProjectId: z.ZodString;
+            versionHash: z.ZodString;
+            publication: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            profileHash: z.ZodString;
+            variantId: z.ZodString;
+        }, z.core.$strict>>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            tokenIds: z.ZodArray<z.ZodNumber>;
+            attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        }, z.core.$strict>>;
+        variants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            profile: z.ZodNullable<z.ZodLazy<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronSteeringProfile.v1">;
+                model: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+                    modelId: z.ZodString;
+                    revision: z.ZodString;
+                    configHash: z.ZodString;
+                    weightsHash: z.ZodString;
+                    tokenizerHash: z.ZodString;
+                    weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+                    architecture: z.ZodLiteral<"dense_decoder">;
+                    dtype: z.ZodEnum<{
+                        bfloat16: "bfloat16";
+                        float16: "float16";
+                        float32: "float32";
+                    }>;
+                    quantization: z.ZodLiteral<"none">;
+                    adapter: z.ZodNull;
+                    hiddenSize: z.ZodNumber;
+                    intermediateSizes: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>;
+                hook: z.ZodLiteral<"mlp.down_proj.input">;
+                operation: z.ZodLiteral<"add">;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+                    statistic: z.ZodLiteral<"midpoint_median_fp32">;
+                    sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"fixed_residual_reference">;
+                    calibration: z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>], "mode">;
+                tokenScope: z.ZodObject<{
+                    phase: z.ZodEnum<{
+                        decode_only: "decode_only";
+                        prompt_and_decode: "prompt_and_decode";
+                        prompt_only: "prompt_only";
+                    }>;
+                    positions: z.ZodEnum<{
+                        after_position_zero: "after_position_zero";
+                        all_non_padding: "all_non_padding";
+                    }>;
+                }, z.core.$strict>;
+                entries: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                    dose: z.ZodNumber;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        capture: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            neurons: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+        maxNewTokens: z.ZodNumber;
+        eosTokenIds: z.ZodArray<z.ZodNumber>;
+        maximumCapturedValues: z.ZodNumber;
+        maximumForwardTokenWork: z.ZodNumber;
+        maximumDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    sourceForm: z.ZodOptional<z.ZodObject<{
+        baseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        startingProfile: z.ZodOptional<z.ZodObject<{
+            modelProjectId: z.ZodString;
+            versionHash: z.ZodString;
+            publication: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            profileHash: z.ZodString;
+        }, z.core.$strict>>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+        coordinates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            layer: z.ZodString;
+            neuron: z.ZodString;
+            dose: z.ZodString;
+        }, z.core.$strict>>;
+        doseMultipliers: z.ZodString;
+        normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+            statistic: z.ZodLiteral<"midpoint_median_fp32">;
+            sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"fixed_residual_reference">;
+            calibration: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "mode">;
+        tokenScope: z.ZodObject<{
+            phase: z.ZodEnum<{
+                decode_only: "decode_only";
+                prompt_and_decode: "prompt_and_decode";
+                prompt_only: "prompt_only";
+            }>;
+            positions: z.ZodEnum<{
+                after_position_zero: "after_position_zero";
+                all_non_padding: "all_non_padding";
+            }>;
+        }, z.core.$strict>;
+        maxNewTokens: z.ZodString;
+        maximumCapturedValues: z.ZodString;
+        maximumForwardTokenWork: z.ZodString;
+        maximumDurationSeconds: z.ZodString;
+        maximumSpendUsd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceResult.v1">;
+        requestHash: z.ZodString;
+        modelHash: z.ZodString;
+        runtime: z.ZodObject<{
+            implementation: z.ZodLiteral<"torch_dense_serial_reference_v1">;
+            implementationHash: z.ZodString;
+            torchVersion: z.ZodString;
+            device: z.ZodString;
+        }, z.core.$strict>;
+        outcomes: z.ZodArray<z.ZodObject<{
+            promptId: z.ZodString;
+            variantId: z.ZodString;
+            profileHash: z.ZodNullable<z.ZodString>;
+            generatedTokenIds: z.ZodArray<z.ZodNumber>;
+            forwardTokenWork: z.ZodNumber;
+            calibration: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                median: z.ZodNumber;
+                sampleCount: z.ZodNumber;
+                columnNorms: z.ZodArray<z.ZodObject<{
+                    neuron: z.ZodNumber;
+                    norm: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            durationMs: z.ZodNumber;
+            captureCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        captures: z.ZodArray<z.ZodObject<{
+            promptId: z.ZodString;
+            variantId: z.ZodString;
+            layer: z.ZodNumber;
+            neuron: z.ZodNumber;
+            tokenIndex: z.ZodNumber;
+            tokenId: z.ZodNumber;
+            before: z.ZodNumber;
+            after: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    resultRecordedAt: z.ZodNullable<z.ZodISODateTime>;
+    updatedAt: z.ZodISODateTime;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ManagedModificationExecution = z.infer<typeof ManagedModificationExecutionSchema>;
+/** Requested inputs only. Runtime selection and paid admission belong to the host. */
+export declare const ManagedModificationPrepareSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    method: z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>;
+    query: z.ZodObject<{
+        teamId: z.ZodString;
+        modelId: z.ZodString;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+        revision: z.ZodOptional<z.ZodString>;
+        tokenizerRevision: z.ZodOptional<z.ZodString>;
+        chatTemplateHash: z.ZodOptional<z.ZodString>;
+        modelAssetId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceRequest.v1">;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        startingProfile: z.ZodOptional<z.ZodObject<{
+            modelProjectId: z.ZodString;
+            versionHash: z.ZodString;
+            publication: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            profileHash: z.ZodString;
+            variantId: z.ZodString;
+        }, z.core.$strict>>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            tokenIds: z.ZodArray<z.ZodNumber>;
+            attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        }, z.core.$strict>>;
+        variants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            profile: z.ZodNullable<z.ZodLazy<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronSteeringProfile.v1">;
+                model: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+                    modelId: z.ZodString;
+                    revision: z.ZodString;
+                    configHash: z.ZodString;
+                    weightsHash: z.ZodString;
+                    tokenizerHash: z.ZodString;
+                    weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+                    architecture: z.ZodLiteral<"dense_decoder">;
+                    dtype: z.ZodEnum<{
+                        bfloat16: "bfloat16";
+                        float16: "float16";
+                        float32: "float32";
+                    }>;
+                    quantization: z.ZodLiteral<"none">;
+                    adapter: z.ZodNull;
+                    hiddenSize: z.ZodNumber;
+                    intermediateSizes: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>;
+                hook: z.ZodLiteral<"mlp.down_proj.input">;
+                operation: z.ZodLiteral<"add">;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+                    statistic: z.ZodLiteral<"midpoint_median_fp32">;
+                    sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"fixed_residual_reference">;
+                    calibration: z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>], "mode">;
+                tokenScope: z.ZodObject<{
+                    phase: z.ZodEnum<{
+                        decode_only: "decode_only";
+                        prompt_and_decode: "prompt_and_decode";
+                        prompt_only: "prompt_only";
+                    }>;
+                    positions: z.ZodEnum<{
+                        after_position_zero: "after_position_zero";
+                        all_non_padding: "all_non_padding";
+                    }>;
+                }, z.core.$strict>;
+                entries: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                    dose: z.ZodNumber;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        capture: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            neurons: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+        maxNewTokens: z.ZodNumber;
+        eosTokenIds: z.ZodArray<z.ZodNumber>;
+        maximumCapturedValues: z.ZodNumber;
+        maximumForwardTokenWork: z.ZodNumber;
+        maximumDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    maximumSpendUsd: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sourceForm: z.ZodOptional<z.ZodObject<{
+        baseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        startingProfile: z.ZodOptional<z.ZodObject<{
+            modelProjectId: z.ZodString;
+            versionHash: z.ZodString;
+            publication: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            profileHash: z.ZodString;
+        }, z.core.$strict>>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+        coordinates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            layer: z.ZodString;
+            neuron: z.ZodString;
+            dose: z.ZodString;
+        }, z.core.$strict>>;
+        doseMultipliers: z.ZodString;
+        normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+            statistic: z.ZodLiteral<"midpoint_median_fp32">;
+            sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"fixed_residual_reference">;
+            calibration: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "mode">;
+        tokenScope: z.ZodObject<{
+            phase: z.ZodEnum<{
+                decode_only: "decode_only";
+                prompt_and_decode: "prompt_and_decode";
+                prompt_only: "prompt_only";
+            }>;
+            positions: z.ZodEnum<{
+                after_position_zero: "after_position_zero";
+                all_non_padding: "all_non_padding";
+            }>;
+        }, z.core.$strict>;
+        maxNewTokens: z.ZodString;
+        maximumCapturedValues: z.ZodString;
+        maximumForwardTokenWork: z.ZodString;
+        maximumDurationSeconds: z.ZodString;
+        maximumSpendUsd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ManagedModificationStartSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    planHash: z.ZodString;
+    action: z.ZodLiteral<"start">;
+    approvedMaximumSpendUsd: z.ZodNullable<z.ZodString>;
+    approvedPriceHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ManagedModificationCancelSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    planHash: z.ZodString;
+    action: z.ZodLiteral<"cancel">;
+}, z.core.$strict>;
+export type ManagedModificationPrepare = z.infer<typeof ManagedModificationPrepareSchema>;
+export type ManagedModificationStart = z.infer<typeof ManagedModificationStartSchema>;
+export type ManagedModificationCancel = z.infer<typeof ManagedModificationCancelSchema>;
+export declare const ManagedModificationExecutionMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    method: z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>;
+    revision: z.ZodNumber;
+    sourceContentHash: z.ZodString;
+    plan: z.ZodObject<{
+        contentHash: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        maximumSpendUsd: z.ZodNullable<z.ZodString>;
+        computePrice: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            warmReuseSeconds: z.ZodLiteral<300>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const ManagedModificationExecutionReceiptContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedModificationExecutionReceipt.v1">;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    execution: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        method: z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>;
+        revision: z.ZodNumber;
+        sourceContentHash: z.ZodString;
+        plan: z.ZodObject<{
+            contentHash: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            maximumSpendUsd: z.ZodNullable<z.ZodString>;
+            computePrice: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                warmReuseSeconds: z.ZodLiteral<300>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ManagedModificationExecutionReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedModificationExecutionReceipt.v1">;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    execution: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        method: z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>;
+        revision: z.ZodNumber;
+        sourceContentHash: z.ZodString;
+        plan: z.ZodObject<{
+            contentHash: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            maximumSpendUsd: z.ZodNullable<z.ZodString>;
+            computePrice: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                warmReuseSeconds: z.ZodLiteral<300>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ManagedModificationExecutionReceipt = z.infer<typeof ManagedModificationExecutionReceiptSchema>;
+/** Metadata-only creator history. A page grants neither execution nor capture authority. */
+export declare const ManagedModificationExecutionListQuerySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    method: z.ZodOptional<z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>>;
+    phase: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ManagedModificationExecutionListQuery = z.input<typeof ManagedModificationExecutionListQuerySchema>;
+export declare const ManagedModificationExecutionSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    method: z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>;
+    phase: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        dispatching: "dispatching";
+        failed: "failed";
+        prepared: "prepared";
+        queued: "queued";
+        stopping: "stopping";
+    }>;
+    revision: z.ZodNumber;
+    sourceContentHash: z.ZodString;
+    plan: z.ZodObject<{
+        contentHash: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        maximumSpendUsd: z.ZodNullable<z.ZodString>;
+        computePrice: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+            appliedPrice: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                version: z.ZodString;
+                profileHash: z.ZodString;
+                currency: z.ZodLiteral<"USD">;
+                unit: z.ZodLiteral<"resource_hour">;
+                hourlyUsd: z.ZodString;
+                service: z.ZodLiteral<"model_modification">;
+            }, z.core.$strict>;
+            billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+            startupBillable: z.ZodLiteral<true>;
+            postCompletionIdleBillable: z.ZodLiteral<false>;
+            minimumBillableSeconds: z.ZodLiteral<0>;
+            warmReuseSeconds: z.ZodLiteral<300>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    model: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodString;
+        configHash: z.ZodString;
+        weightsHash: z.ZodString;
+        tokenizerHash: z.ZodString;
+        weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+        architecture: z.ZodLiteral<"dense_decoder">;
+        dtype: z.ZodEnum<{
+            bfloat16: "bfloat16";
+            float16: "float16";
+            float32: "float32";
+        }>;
+        quantization: z.ZodLiteral<"none">;
+        adapter: z.ZodNull;
+        hiddenSize: z.ZodNumber;
+        intermediateSizes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ManagedModificationExecutionSummary = z.infer<typeof ManagedModificationExecutionSummarySchema>;
+export declare const ManagedModificationExecutionPageContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedModificationExecutionPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    query: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        method: z.ZodOptional<z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        method: z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>;
+        revision: z.ZodNumber;
+        sourceContentHash: z.ZodString;
+        plan: z.ZodObject<{
+            contentHash: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            maximumSpendUsd: z.ZodNullable<z.ZodString>;
+            computePrice: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                warmReuseSeconds: z.ZodLiteral<300>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const ManagedModificationExecutionPageSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.managedModificationExecutionPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    query: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        method: z.ZodOptional<z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        method: z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>;
+        phase: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            dispatching: "dispatching";
+            failed: "failed";
+            prepared: "prepared";
+            queued: "queued";
+            stopping: "stopping";
+        }>;
+        revision: z.ZodNumber;
+        sourceContentHash: z.ZodString;
+        plan: z.ZodObject<{
+            contentHash: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            maximumSpendUsd: z.ZodNullable<z.ZodString>;
+            computePrice: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.modificationPrice.v1">;
+                appliedPrice: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.computeAppliedPrice.v1">;
+                    version: z.ZodString;
+                    profileHash: z.ZodString;
+                    currency: z.ZodLiteral<"USD">;
+                    unit: z.ZodLiteral<"resource_hour">;
+                    hourlyUsd: z.ZodString;
+                    service: z.ZodLiteral<"model_modification">;
+                }, z.core.$strict>;
+                billingBoundary: z.ZodLiteral<"active_allocation_until_verified_cleanup">;
+                startupBillable: z.ZodLiteral<true>;
+                postCompletionIdleBillable: z.ZodLiteral<false>;
+                minimumBillableSeconds: z.ZodLiteral<0>;
+                warmReuseSeconds: z.ZodLiteral<300>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        updatedAt: z.ZodISODateTime;
+        model: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ManagedModificationExecutionPage = z.infer<typeof ManagedModificationExecutionPageSchema>;
+export declare function parseAndVerifyManagedModificationExecutionPage(raw: unknown, expected: {
+    teamId: string;
+    query?: ManagedModificationExecutionListQuery;
+    ownerUserId?: string;
+}): Promise<ManagedModificationExecutionPage>;
+export declare function canonicalModificationSpend(value: string): string;
+export declare function parseAndVerifyManagedModificationPrepare(raw: unknown): Promise<ManagedModificationPrepare>;
+export declare function parseManagedModificationControl(raw: unknown): ManagedModificationStart | ManagedModificationCancel;
+/** The receipt projects the original immutable owner receipt. Capture bytes are
+ * read separately; a later execution read cannot replace mutation history. */
+export declare function parseAndVerifyManagedModificationExecutionReceipt(raw: unknown, input: ManagedModificationPrepare | ManagedModificationStart | ManagedModificationCancel): Promise<{
+    schemaVersion: "openpond.managedModificationExecutionReceipt.v1";
+    operationId: string;
+    requestHash: string;
+    execution: {
+        id: string;
+        teamId: string;
+        ownerUserId: string;
+        projectId: string | null;
+        name: string;
+        method: "inspect_activations" | "neuron_steering";
+        phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+        revision: number;
+        sourceContentHash: string;
+        plan: {
+            contentHash: string;
+            inputHash: string;
+            runtimeHash: string;
+            maximumSpendUsd: string | null;
+            computePrice?: {
+                schemaVersion: "openpond.modificationPrice.v1";
+                appliedPrice: {
+                    schemaVersion: "openpond.computeAppliedPrice.v1";
+                    version: string;
+                    profileHash: string;
+                    currency: "USD";
+                    unit: "resource_hour";
+                    hourlyUsd: string;
+                    service: "model_modification";
+                };
+                billingBoundary: "active_allocation_until_verified_cleanup";
+                startupBillable: true;
+                postCompletionIdleBillable: false;
+                minimumBillableSeconds: 0;
+                warmReuseSeconds: 300;
+            } | undefined;
+            createdAt: string;
+            expiresAt: string;
+        };
+        updatedAt: string;
+    };
+    contentHash: string;
+}>;
+export declare function parseAndVerifyManagedModificationExecution(raw: unknown, expected: {
+    teamId: string;
+    id: string;
+    ownerUserId?: string;
+}): Promise<ManagedModificationExecution>;
+export declare const MANAGED_MODIFICATION_EXECUTION_RESPONSE_MAX_BYTES: number;
+export declare function createManagedModificationExecutionClient(request: (path: string, init?: RequestInit, responseLimit?: number) => Promise<unknown>): {
+    compileModificationExecution(input: ManagedModificationCompile): Promise<{
+        schemaVersion: "openpond.managedModificationCompilation.v1";
+        teamId: string;
+        actorId: string;
+        projectId: string | null;
+        method: "inspect_activations" | "neuron_steering";
+        query: {
+            teamId: string;
+            modelId: string;
+            source: "builtin" | "local" | "managed";
+            revision?: string | undefined;
+            tokenizerRevision?: string | undefined;
+            chatTemplateHash?: string | undefined;
+            modelAssetId?: string | undefined;
+        };
+        formHash: string;
+        request: {
+            schemaVersion: "openpond.activationReferenceRequest.v1";
+            model: {
+                schemaVersion: "openpond.neuronSteeringModel.v1";
+                modelId: string;
+                revision: string;
+                configHash: string;
+                weightsHash: string;
+                tokenizerHash: string;
+                weightIdentity: "torch_state_dict_sha256_v1";
+                architecture: "dense_decoder";
+                dtype: "bfloat16" | "float16" | "float32";
+                quantization: "none";
+                adapter: null;
+                hiddenSize: number;
+                intermediateSizes: number[];
+            };
+            startingProfile?: {
+                modelProjectId: string;
+                versionHash: string;
+                publication: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                profileHash: string;
+                variantId: string;
+            } | undefined;
+            prompts: {
+                id: string;
+                tokenIds: number[];
+                attentionMask: (0 | 1)[];
+            }[];
+            variants: {
+                id: string;
+                profile: {
+                    schemaVersion: "openpond.neuronSteeringProfile.v1";
+                    model: {
+                        schemaVersion: "openpond.neuronSteeringModel.v1";
+                        modelId: string;
+                        revision: string;
+                        configHash: string;
+                        weightsHash: string;
+                        tokenizerHash: string;
+                        weightIdentity: "torch_state_dict_sha256_v1";
+                        architecture: "dense_decoder";
+                        dtype: "bfloat16" | "float16" | "float32";
+                        quantization: "none";
+                        adapter: null;
+                        hiddenSize: number;
+                        intermediateSizes: number[];
+                    };
+                    hook: "mlp.down_proj.input";
+                    operation: "add";
+                    normalization: {
+                        mode: "baseline_prompt_residual_median";
+                        statistic: "midpoint_median_fp32";
+                        sample: "non_padding_prompt_after_position_zero";
+                    } | {
+                        mode: "fixed_residual_reference";
+                        calibration: {
+                            id: string;
+                            revision: number;
+                            contentHash: string;
+                        };
+                    };
+                    tokenScope: {
+                        phase: "decode_only" | "prompt_and_decode" | "prompt_only";
+                        positions: "after_position_zero" | "all_non_padding";
+                    };
+                    entries: {
+                        layer: number;
+                        neuron: number;
+                        dose: number;
+                    }[];
+                    contentHash: string;
+                } | null;
+            }[];
+            capture: {
+                layer: number;
+                neurons: number[];
+            }[];
+            maxNewTokens: number;
+            eosTokenIds: number[];
+            maximumCapturedValues: number;
+            maximumForwardTokenWork: number;
+            maximumDurationSeconds: number;
+        };
+        inputHash: string;
+        contentHash: string;
+    }>;
+    prepareModificationExecution(input: ManagedModificationPrepare): Promise<{
+        schemaVersion: "openpond.managedModificationExecutionReceipt.v1";
+        operationId: string;
+        requestHash: string;
+        execution: {
+            id: string;
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            method: "inspect_activations" | "neuron_steering";
+            phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+            revision: number;
+            sourceContentHash: string;
+            plan: {
+                contentHash: string;
+                inputHash: string;
+                runtimeHash: string;
+                maximumSpendUsd: string | null;
+                computePrice?: {
+                    schemaVersion: "openpond.modificationPrice.v1";
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    warmReuseSeconds: 300;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+        };
+        contentHash: string;
+    }>;
+    startModificationExecution(input: ManagedModificationStart): Promise<{
+        schemaVersion: "openpond.managedModificationExecutionReceipt.v1";
+        operationId: string;
+        requestHash: string;
+        execution: {
+            id: string;
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            method: "inspect_activations" | "neuron_steering";
+            phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+            revision: number;
+            sourceContentHash: string;
+            plan: {
+                contentHash: string;
+                inputHash: string;
+                runtimeHash: string;
+                maximumSpendUsd: string | null;
+                computePrice?: {
+                    schemaVersion: "openpond.modificationPrice.v1";
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    warmReuseSeconds: 300;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+        };
+        contentHash: string;
+    }>;
+    cancelModificationExecution(input: ManagedModificationCancel): Promise<{
+        schemaVersion: "openpond.managedModificationExecutionReceipt.v1";
+        operationId: string;
+        requestHash: string;
+        execution: {
+            id: string;
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            method: "inspect_activations" | "neuron_steering";
+            phase: "cancelled" | "completed" | "dispatching" | "failed" | "prepared" | "queued" | "stopping";
+            revision: number;
+            sourceContentHash: string;
+            plan: {
+                contentHash: string;
+                inputHash: string;
+                runtimeHash: string;
+                maximumSpendUsd: string | null;
+                computePrice?: {
+                    schemaVersion: "openpond.modificationPrice.v1";
+                    appliedPrice: {
+                        schemaVersion: "openpond.computeAppliedPrice.v1";
+                        version: string;
+                        profileHash: string;
+                        currency: "USD";
+                        unit: "resource_hour";
+                        hourlyUsd: string;
+                        service: "model_modification";
+                    };
+                    billingBoundary: "active_allocation_until_verified_cleanup";
+                    startupBillable: true;
+                    postCompletionIdleBillable: false;
+                    minimumBillableSeconds: 0;
+                    warmReuseSeconds: 300;
+                } | undefined;
+                createdAt: string;
+                expiresAt: string;
+            };
+            updatedAt: string;
+        };
+        contentHash: string;
+    }>;
+    listModificationExecutions(teamId: string, query?: ManagedModificationExecutionListQuery, options?: {
+        signal?: AbortSignal;
+        ownerUserId?: string;
+    }): Promise<ManagedModificationExecutionPage>;
+    getModificationExecution(teamId: string, id: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<ManagedModificationExecution>;
+};
+//# sourceMappingURL=managed-modification-executions.d.ts.map