openpond-sdk 0.12.13 → 0.12.15

package/dist/types/packages/sdk/src/neuron-calibration-records.d.ts

@@ -0,0 +1,816 @@
+import { z } from "zod";
+/** Custody proves the retained original bytes and scope. Qualification is a
+ * separate runtime authority decision, never granted by importing an export. */
+export declare const NeuronCalibrationRecordContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronCalibrationRecord.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    artifact: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibrationExport.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>;
+        prompt: 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>;
+        calibration: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            modelHash: z.ZodString;
+            source: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            statistic: z.ZodLiteral<"midpoint_median_fp32">;
+            sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+            layers: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                median: z.ZodNumber;
+                sampleCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            implementation: z.ZodLiteral<"torch_dense_serial_calibration_v1">;
+            implementationHash: z.ZodString;
+            torchVersion: z.ZodString;
+            device: z.ZodString;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    revision: z.ZodNumber;
+    archived: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const NeuronCalibrationRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronCalibrationRecord.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    artifact: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibrationExport.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>;
+        prompt: 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>;
+        calibration: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            modelHash: z.ZodString;
+            source: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            statistic: z.ZodLiteral<"midpoint_median_fp32">;
+            sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+            layers: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                median: z.ZodNumber;
+                sampleCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            implementation: z.ZodLiteral<"torch_dense_serial_calibration_v1">;
+            implementationHash: z.ZodString;
+            torchVersion: z.ZodString;
+            device: z.ZodString;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    revision: z.ZodNumber;
+    archived: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronCalibrationRecord = z.infer<typeof NeuronCalibrationRecordSchema>;
+export declare const NeuronCalibrationImportRequestSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    artifact: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibrationExport.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>;
+        prompt: 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>;
+        calibration: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            modelHash: z.ZodString;
+            source: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            statistic: z.ZodLiteral<"midpoint_median_fp32">;
+            sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+            layers: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                median: z.ZodNumber;
+                sampleCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            implementation: z.ZodLiteral<"torch_dense_serial_calibration_v1">;
+            implementationHash: z.ZodString;
+            torchVersion: z.ZodString;
+            device: z.ZodString;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type NeuronCalibrationImportRequest = z.infer<typeof NeuronCalibrationImportRequestSchema>;
+export declare const NeuronCalibrationReadQuerySchema: z.ZodObject<{
+    teamId: z.ZodString;
+}, z.core.$strict>;
+export declare const NeuronCalibrationArchiveRequestSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronCalibrationArchiveRequest = z.infer<typeof NeuronCalibrationArchiveRequestSchema>;
+export declare const NeuronCalibrationReceiptContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronCalibrationReceipt.v1">;
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    record: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronCalibrationRecord.v1">;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        artifact: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibrationExport.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>;
+            prompt: 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>;
+            calibration: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                modelHash: z.ZodString;
+                source: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                statistic: z.ZodLiteral<"midpoint_median_fp32">;
+                sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+                layers: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    median: z.ZodNumber;
+                    sampleCount: z.ZodNumber;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            runtime: z.ZodObject<{
+                implementation: z.ZodLiteral<"torch_dense_serial_calibration_v1">;
+                implementationHash: z.ZodString;
+                torchVersion: z.ZodString;
+                device: z.ZodString;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        revision: z.ZodNumber;
+        archived: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const NeuronCalibrationReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronCalibrationReceipt.v1">;
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    record: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronCalibrationRecord.v1">;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        artifact: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibrationExport.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>;
+            prompt: 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>;
+            calibration: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                modelHash: z.ZodString;
+                source: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                statistic: z.ZodLiteral<"midpoint_median_fp32">;
+                sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+                layers: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    median: z.ZodNumber;
+                    sampleCount: z.ZodNumber;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            runtime: z.ZodObject<{
+                implementation: z.ZodLiteral<"torch_dense_serial_calibration_v1">;
+                implementationHash: z.ZodString;
+                torchVersion: z.ZodString;
+                device: z.ZodString;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        revision: z.ZodNumber;
+        archived: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronCalibrationReceipt = z.infer<typeof NeuronCalibrationReceiptSchema>;
+export declare const NeuronCalibrationListQuerySchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    modelHash: z.ZodOptional<z.ZodString>;
+    archived: z.ZodDefault<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const NeuronCalibrationSummarySchema: z.ZodObject<{
+    reference: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    exportHash: z.ZodString;
+    modelHash: z.ZodString;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    implementationHash: z.ZodString;
+    layerCount: z.ZodNumber;
+    revision: z.ZodNumber;
+    archived: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const NeuronCalibrationPageContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronCalibrationPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    query: z.ZodObject<{
+        projectId: z.ZodOptional<z.ZodString>;
+        modelHash: z.ZodOptional<z.ZodString>;
+        archived: z.ZodDefault<z.ZodBoolean>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        reference: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        exportHash: z.ZodString;
+        modelHash: z.ZodString;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        implementationHash: z.ZodString;
+        layerCount: z.ZodNumber;
+        revision: z.ZodNumber;
+        archived: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const NeuronCalibrationPageSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronCalibrationPage.v1">;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    query: z.ZodObject<{
+        projectId: z.ZodOptional<z.ZodString>;
+        modelHash: z.ZodOptional<z.ZodString>;
+        archived: z.ZodDefault<z.ZodBoolean>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        reference: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        exportHash: z.ZodString;
+        modelHash: z.ZodString;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        implementationHash: z.ZodString;
+        layerCount: z.ZodNumber;
+        revision: z.ZodNumber;
+        archived: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronCalibrationPage = z.infer<typeof NeuronCalibrationPageSchema>;
+export declare function parseAndVerifyNeuronCalibrationRecord(raw: unknown, expected?: {
+    teamId?: string;
+    ownerUserId?: string;
+    id?: string;
+}): Promise<{
+    schemaVersion: "openpond.neuronCalibrationRecord.v1";
+    teamId: string;
+    ownerUserId: string;
+    projectId: string | null;
+    name: string;
+    artifact: {
+        schemaVersion: "openpond.neuronResidualCalibrationExport.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[];
+        };
+        prompt: {
+            id: string;
+            tokenIds: number[];
+            attentionMask: (0 | 1)[];
+        };
+        calibration: {
+            schemaVersion: "openpond.neuronResidualCalibration.v1";
+            id: string;
+            revision: number;
+            modelHash: string;
+            source: {
+                id: string;
+                contentHash: string;
+            };
+            statistic: "midpoint_median_fp32";
+            sample: "non_padding_prompt_after_position_zero";
+            layers: {
+                layer: number;
+                median: number;
+                sampleCount: number;
+            }[];
+            contentHash: string;
+        };
+        runtime: {
+            implementation: "torch_dense_serial_calibration_v1";
+            implementationHash: string;
+            torchVersion: string;
+            device: string;
+        };
+        contentHash: string;
+    };
+    revision: number;
+    archived: boolean;
+    createdAt: string;
+    updatedAt: string;
+    contentHash: string;
+}>;
+export declare function parseAndVerifyNeuronCalibrationReceipt(raw: unknown, request: NeuronCalibrationImportRequest | NeuronCalibrationArchiveRequest, id?: string): Promise<{
+    schemaVersion: "openpond.neuronCalibrationReceipt.v1";
+    teamId: string;
+    actorId: string;
+    operationId: string;
+    requestHash: string;
+    record: {
+        schemaVersion: "openpond.neuronCalibrationRecord.v1";
+        teamId: string;
+        ownerUserId: string;
+        projectId: string | null;
+        name: string;
+        artifact: {
+            schemaVersion: "openpond.neuronResidualCalibrationExport.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[];
+            };
+            prompt: {
+                id: string;
+                tokenIds: number[];
+                attentionMask: (0 | 1)[];
+            };
+            calibration: {
+                schemaVersion: "openpond.neuronResidualCalibration.v1";
+                id: string;
+                revision: number;
+                modelHash: string;
+                source: {
+                    id: string;
+                    contentHash: string;
+                };
+                statistic: "midpoint_median_fp32";
+                sample: "non_padding_prompt_after_position_zero";
+                layers: {
+                    layer: number;
+                    median: number;
+                    sampleCount: number;
+                }[];
+                contentHash: string;
+            };
+            runtime: {
+                implementation: "torch_dense_serial_calibration_v1";
+                implementationHash: string;
+                torchVersion: string;
+                device: string;
+            };
+            contentHash: string;
+        };
+        revision: number;
+        archived: boolean;
+        createdAt: string;
+        updatedAt: string;
+        contentHash: string;
+    };
+    contentHash: string;
+}>;
+export declare function createNeuronCalibrationClient(request: (path: string, init?: RequestInit) => Promise<unknown>): {
+    importNeuronCalibration(raw: NeuronCalibrationImportRequest): Promise<{
+        schemaVersion: "openpond.neuronCalibrationReceipt.v1";
+        teamId: string;
+        actorId: string;
+        operationId: string;
+        requestHash: string;
+        record: {
+            schemaVersion: "openpond.neuronCalibrationRecord.v1";
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            artifact: {
+                schemaVersion: "openpond.neuronResidualCalibrationExport.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[];
+                };
+                prompt: {
+                    id: string;
+                    tokenIds: number[];
+                    attentionMask: (0 | 1)[];
+                };
+                calibration: {
+                    schemaVersion: "openpond.neuronResidualCalibration.v1";
+                    id: string;
+                    revision: number;
+                    modelHash: string;
+                    source: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    statistic: "midpoint_median_fp32";
+                    sample: "non_padding_prompt_after_position_zero";
+                    layers: {
+                        layer: number;
+                        median: number;
+                        sampleCount: number;
+                    }[];
+                    contentHash: string;
+                };
+                runtime: {
+                    implementation: "torch_dense_serial_calibration_v1";
+                    implementationHash: string;
+                    torchVersion: string;
+                    device: string;
+                };
+                contentHash: string;
+            };
+            revision: number;
+            archived: boolean;
+            createdAt: string;
+            updatedAt: string;
+            contentHash: string;
+        };
+        contentHash: string;
+    }>;
+    getNeuronCalibration(teamId: string, id: string): Promise<{
+        schemaVersion: "openpond.neuronCalibrationRecord.v1";
+        teamId: string;
+        ownerUserId: string;
+        projectId: string | null;
+        name: string;
+        artifact: {
+            schemaVersion: "openpond.neuronResidualCalibrationExport.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[];
+            };
+            prompt: {
+                id: string;
+                tokenIds: number[];
+                attentionMask: (0 | 1)[];
+            };
+            calibration: {
+                schemaVersion: "openpond.neuronResidualCalibration.v1";
+                id: string;
+                revision: number;
+                modelHash: string;
+                source: {
+                    id: string;
+                    contentHash: string;
+                };
+                statistic: "midpoint_median_fp32";
+                sample: "non_padding_prompt_after_position_zero";
+                layers: {
+                    layer: number;
+                    median: number;
+                    sampleCount: number;
+                }[];
+                contentHash: string;
+            };
+            runtime: {
+                implementation: "torch_dense_serial_calibration_v1";
+                implementationHash: string;
+                torchVersion: string;
+                device: string;
+            };
+            contentHash: string;
+        };
+        revision: number;
+        archived: boolean;
+        createdAt: string;
+        updatedAt: string;
+        contentHash: string;
+    }>;
+    archiveNeuronCalibration(id: string, raw: NeuronCalibrationArchiveRequest): Promise<{
+        schemaVersion: "openpond.neuronCalibrationReceipt.v1";
+        teamId: string;
+        actorId: string;
+        operationId: string;
+        requestHash: string;
+        record: {
+            schemaVersion: "openpond.neuronCalibrationRecord.v1";
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            artifact: {
+                schemaVersion: "openpond.neuronResidualCalibrationExport.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[];
+                };
+                prompt: {
+                    id: string;
+                    tokenIds: number[];
+                    attentionMask: (0 | 1)[];
+                };
+                calibration: {
+                    schemaVersion: "openpond.neuronResidualCalibration.v1";
+                    id: string;
+                    revision: number;
+                    modelHash: string;
+                    source: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    statistic: "midpoint_median_fp32";
+                    sample: "non_padding_prompt_after_position_zero";
+                    layers: {
+                        layer: number;
+                        median: number;
+                        sampleCount: number;
+                    }[];
+                    contentHash: string;
+                };
+                runtime: {
+                    implementation: "torch_dense_serial_calibration_v1";
+                    implementationHash: string;
+                    torchVersion: string;
+                    device: string;
+                };
+                contentHash: string;
+            };
+            revision: number;
+            archived: boolean;
+            createdAt: string;
+            updatedAt: string;
+            contentHash: string;
+        };
+        contentHash: string;
+    }>;
+    listNeuronCalibrations(teamId: string, raw?: z.input<typeof NeuronCalibrationListQuerySchema>): Promise<{
+        schemaVersion: "openpond.neuronCalibrationPage.v1";
+        teamId: string;
+        ownerUserId: string;
+        query: {
+            projectId?: string | undefined;
+            modelHash?: string | undefined;
+            archived: boolean;
+            limit: number;
+            cursor?: string | undefined;
+        };
+        items: {
+            reference: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            teamId: string;
+            ownerUserId: string;
+            projectId: string | null;
+            name: string;
+            exportHash: string;
+            modelHash: string;
+            source: {
+                id: string;
+                contentHash: string;
+            };
+            implementationHash: string;
+            layerCount: number;
+            revision: number;
+            archived: boolean;
+            createdAt: string;
+            updatedAt: string;
+        }[];
+        nextCursor: string | null;
+        contentHash: string;
+    }>;
+};
+//# sourceMappingURL=neuron-calibration-records.d.ts.map