openpond-sdk 0.9.5 → 0.9.7

package/dist/types/packages/sdk/src/grader-inspection.d.ts

@@ -0,0 +1,568 @@
+import { z } from "zod";
+export declare const GraderCatalogQuerySchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        type: "type";
+        name: "name";
+        version: "version";
+        projects: "projects";
+        datasets: "datasets";
+        runs: "runs";
+    }>>;
+    direction: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const GraderCatalogPageSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        reward: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            name: z.ZodString;
+            description: z.ZodString;
+            feedbackKey: z.ZodOptional<z.ZodString>;
+            implementation: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodEnum<{
+                    content: "content";
+                    schema: "schema";
+                    artifact: "artifact";
+                    runtime_event: "runtime_event";
+                    state: "state";
+                }>;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"model_judge">;
+                rubricRef: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                calibrationStatus: z.ZodEnum<{
+                    pending: "pending";
+                    passed: "passed";
+                    failed: "failed";
+                }>;
+                model: z.ZodOptional<z.ZodObject<{
+                    providerId: z.ZodString;
+                    modelId: z.ZodString;
+                    revision: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                temperature: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                exportName: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodNumber;
+                networkPolicy: z.ZodLiteral<"none">;
+                kind: z.ZodLiteral<"custom_verifier">;
+                runtime: z.ZodOptional<z.ZodEnum<{
+                    isolated_javascript: "isolated_javascript";
+                    sandbox_process: "sandbox_process";
+                }>>;
+                verifierRef: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"human">;
+                rubricRef: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                reviewerRole: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"learned_model">;
+                modelVersion: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                inputContract: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>;
+            rawScore: z.ZodObject<{
+                minimum: z.ZodNumber;
+                maximum: z.ZodNumber;
+            }, z.core.$strict>;
+            assets: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>;
+            fixtureSetRef: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>;
+            calibrationCheckRef: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        projects: z.ZodNumber;
+        datasets: z.ZodNumber;
+        runs: z.ZodNumber;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const GraderVersionsPageSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    id: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        feedbackKey: z.ZodOptional<z.ZodString>;
+        implementation: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"model_judge">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            calibrationStatus: z.ZodEnum<{
+                pending: "pending";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            model: z.ZodOptional<z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
+            kind: z.ZodLiteral<"custom_verifier">;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                isolated_javascript: "isolated_javascript";
+                sandbox_process: "sandbox_process";
+            }>>;
+            verifierRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"learned_model">;
+            modelVersion: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            inputContract: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        rawScore: z.ZodObject<{
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+        }, z.core.$strict>;
+        assets: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        fixtureSetRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        calibrationCheckRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    nextRevision: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const GraderUsageQuerySchema: z.ZodObject<{
+    section: z.ZodEnum<{
+        projects: "projects";
+        datasets: "datasets";
+        runs: "runs";
+    }>;
+    after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const GraderUsagePageSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    id: z.ZodString;
+    section: z.ZodEnum<{
+        projects: "projects";
+        datasets: "datasets";
+        runs: "runs";
+    }>;
+    items: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        graderRevisions: z.ZodArray<z.ZodNumber>;
+        archived: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        revision: z.ZodNumber;
+        graderRevisions: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodString;
+    }, z.core.$strict>]>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare class OpenPondGraderInspectionClient {
+    private readonly options;
+    private readonly baseUrl;
+    constructor(options: {
+        baseUrl: string;
+        apiKey: string;
+        teamId: string;
+        fetch?: typeof fetch;
+    });
+    catalog(value?: z.input<typeof GraderCatalogQuerySchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        items: {
+            reward: {
+                schemaVersion: "openpond.rewardRelease.v1";
+                id: string;
+                revision: number;
+                name: string;
+                description: string;
+                implementation: {
+                    kind: "content" | "state" | "schema" | "runtime_event" | "artifact";
+                    config: Record<string, unknown>;
+                } | {
+                    kind: "model_judge";
+                    rubricRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                    calibrationStatus: "passed" | "failed" | "pending";
+                    model?: {
+                        providerId: string;
+                        modelId: string;
+                        revision: string | null;
+                    } | undefined;
+                    temperature?: number | undefined;
+                } | {
+                    timeoutMs: number;
+                    networkPolicy: "none";
+                    kind: "custom_verifier";
+                    verifierRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                    exportName?: string | undefined;
+                    runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+                } | {
+                    kind: "human";
+                    rubricRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                    reviewerRole: string;
+                } | {
+                    kind: "learned_model";
+                    modelVersion: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    inputContract: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                };
+                rawScore: {
+                    minimum: number;
+                    maximum: number;
+                };
+                assets: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                }[];
+                contentHash: string;
+                feedbackKey?: string | undefined;
+                fixtureSetRef?: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                } | undefined;
+                calibrationCheckRef?: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | undefined;
+            };
+            projects: number;
+            datasets: number;
+            runs: number;
+        }[];
+        nextCursor: string | null;
+    }>;
+    versions(id: string, query?: {
+        beforeRevision?: number;
+        limit?: number;
+    }, signal?: AbortSignal): Promise<{
+        teamId: string;
+        id: string;
+        items: {
+            schemaVersion: "openpond.rewardRelease.v1";
+            id: string;
+            revision: number;
+            name: string;
+            description: string;
+            implementation: {
+                kind: "content" | "state" | "schema" | "runtime_event" | "artifact";
+                config: Record<string, unknown>;
+            } | {
+                kind: "model_judge";
+                rubricRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                calibrationStatus: "passed" | "failed" | "pending";
+                model?: {
+                    providerId: string;
+                    modelId: string;
+                    revision: string | null;
+                } | undefined;
+                temperature?: number | undefined;
+            } | {
+                timeoutMs: number;
+                networkPolicy: "none";
+                kind: "custom_verifier";
+                verifierRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                exportName?: string | undefined;
+                runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+            } | {
+                kind: "human";
+                rubricRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                reviewerRole: string;
+            } | {
+                kind: "learned_model";
+                modelVersion: {
+                    id: string;
+                    contentHash: string;
+                };
+                inputContract: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+            };
+            rawScore: {
+                minimum: number;
+                maximum: number;
+            };
+            assets: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            contentHash: string;
+            feedbackKey?: string | undefined;
+            fixtureSetRef?: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            } | undefined;
+            calibrationCheckRef?: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | undefined;
+        }[];
+        nextRevision: number | null;
+    }>;
+    usage(id: string, value: z.input<typeof GraderUsageQuerySchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        id: string;
+        section: "projects" | "datasets" | "runs";
+        items: ({
+            id: string;
+            name: string;
+            graderRevisions: number[];
+            archived: boolean;
+        } | {
+            id: string;
+            name: string;
+            revision: number;
+            graderRevisions: number[];
+        } | {
+            id: string;
+            name: string;
+            status: string;
+        })[];
+        nextCursor: string | null;
+    }>;
+    private read;
+}
+//# sourceMappingURL=grader-inspection.d.ts.map

package/dist/types/packages/sdk/src/grader-inspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grader-inspection.d.ts","sourceRoot":"","sources":["../../../../../src/grader-inspection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;kBAAkW,CAAC;AACxY,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA8Q,CAAC;AACnT,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAgJ,CAAC;AACtL,eAAO,MAAM,sBAAsB;;;;;;;;kBAAsJ,CAAC;AAC1L,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;kBAIiB,CAAC;AACpD,qBAAa,8BAA8B;IAE7B,OAAO,CAAC,QAAQ,CAAC,OAAO;IADpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBACJ,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;KAAE;IAKzG,OAAO,CAAC,KAAK,GAAE,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAM,EAAE,MAAM,CAAC,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMlF,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,GAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,EAAE,MAAM,CAAC,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMlG,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;YAM7E,IAAI;CAOnB"}

package/dist/types/packages/sdk/src/learning-batch-assets.d.ts

@@ -36,7 +36,7 @@ export declare function materializeLearningBatchAssets(input: {
             mediaType: string;
             sha256: string;
             sizeBytes: number;
-            split: "train" | "validation" | "test" | "frozen_eval";
+            split: "train" | "validation" | "frozen_eval" | "test";
             metadata: {
                 portableAsset: {
                     id: string;
@@ -50,7 +50,7 @@ export declare function materializeLearningBatchAssets(input: {
         }[];
         id: string;
         clusterKey: string;
-        split: "train" | "validation" | "test" | "frozen_eval";
+        split: "train" | "validation" | "frozen_eval" | "test";
         input: Record<string, unknown>;
         expectedOutput: Record<string, unknown> | null;
         policyVisibleContext: Record<string, unknown>;

package/dist/types/packages/sdk/src/learning-client.d.ts

@@ -199,7 +199,7 @@ export declare class OpenPondLearningClient {
             revision: number;
         };
         enabled: boolean;
-        allowedSplits: ("train" | "validation" | "test" | "frozen_eval")[];
+        allowedSplits: ("train" | "validation" | "frozen_eval" | "test")[];
     }>;
     list<K extends LearningResourceKind>(kind: K, query?: Partial<LearningResourceQuery>, options?: LearningRequestOptions): Promise<LearningResourcePage<K>>;
     /** Hosted publication only: stores an immutable package and attaches it, without starting training. */

package/dist/types/packages/sdk/src/learning.d.ts

@@ -3,4 +3,5 @@ export * from "@openpond/evals/rewards";
 export * from "./learning-credentials.js";
 export * from "./learning-client.js";
 export * from "./model-learning-policy.js";
+export * from "./grader-inspection.js";
 //# sourceMappingURL=learning.d.ts.map

package/dist/types/packages/sdk/src/learning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"learning.d.ts","sourceRoot":"","sources":["../../../../../src/learning.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"learning.d.ts","sourceRoot":"","sources":["../../../../../src/learning.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAE3C,cAAc,wBAAwB,CAAC"}

package/dist/types/packages/sdk/src/managed-training-preparation.d.ts

@@ -97,7 +97,7 @@ export declare function prepareManagedTrainingSubmission(raw: ManagedTrainingPre
                 tokenizerRevision: string | null;
                 chatTemplateHash: string | null;
                 modelAssetId: string | null;
-                source: "local" | "builtin" | "managed";
+                source: "local" | "managed" | "builtin";
             };
             preferenceDatasetRelease: {
                 id: string;
@@ -122,7 +122,7 @@ export declare function prepareManagedTrainingSubmission(raw: ManagedTrainingPre
                 tokenizerRevision: string | null;
                 chatTemplateHash: string | null;
                 modelAssetId: string | null;
-                source: "local" | "builtin" | "managed";
+                source: "local" | "managed" | "builtin";
             };
             recipe: {
                 [x: string]: unknown;