openpond-sdk 0.12.3 → 0.12.5

package/dist/types/packages/sdk/src/taskset-draft-document.d.ts

@@ -4,10 +4,10 @@ export declare const TaskDataDraftSchema: z.ZodObject<{
     id: z.ZodString;
     clusterKey: z.ZodString;
     split: z.ZodEnum<{
+        frozen_eval: "frozen_eval";
+        test: "test";
         train: "train";
         validation: "validation";
-        test: "test";
-        frozen_eval: "frozen_eval";
     }>;
     input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -23,10 +23,10 @@ export declare const TaskDataDraftSchema: z.ZodObject<{
         sha256: z.ZodString;
         sizeBytes: z.ZodNumber;
         split: z.ZodEnum<{
+            frozen_eval: "frozen_eval";
+            test: "test";
             train: "train";
             validation: "validation";
-            test: "test";
-            frozen_eval: "frozen_eval";
         }>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>>;
@@ -35,6 +35,7 @@ export declare const TaskDataDraftSchema: z.ZodObject<{
         path: z.ZodString;
         mediaType: z.ZodString;
         schemaRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
         maxBytes: z.ZodOptional<z.ZodNumber>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>>;
@@ -44,9 +45,9 @@ export declare const TaskDataDraftSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const TasksetDraftStatusSchema: z.ZodEnum<{
     draft: "draft";
-    validating: "validating";
     needs_review: "needs_review";
     published: "published";
+    validating: "validating";
 }>;
 export declare const TasksetDraftReviewPolicySchema: z.ZodObject<{
     enabled: z.ZodBoolean;
@@ -64,9 +65,9 @@ export declare const TasksetDraftReviewPolicySchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const TasksetDraftOutputContractSchema: z.ZodObject<{
     mode: z.ZodEnum<{
-        text: "text";
-        structured_json: "structured_json";
         artifacts: "artifacts";
+        structured_json: "structured_json";
+        text: "text";
     }>;
     jsonSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     renderer: z.ZodNullable<z.ZodObject<{
@@ -118,8 +119,8 @@ export declare const TasksetDraftSchema: z.ZodObject<{
     name: z.ZodString;
     objective: z.ZodString;
     purpose: z.ZodDefault<z.ZodEnum<{
-        general: "general";
         benchmark: "benchmark";
+        general: "general";
     }>>;
     benchmark: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.tasksetBenchmark.v1">;
@@ -128,27 +129,27 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         releaseHash: z.ZodString;
         managedReleasePath: z.ZodString;
         adaptationSplit: z.ZodEnum<{
+            frozen_eval: "frozen_eval";
+            test: "test";
             train: "train";
             validation: "validation";
-            test: "test";
-            frozen_eval: "frozen_eval";
         }>;
         evaluationSplit: z.ZodEnum<{
+            frozen_eval: "frozen_eval";
+            test: "test";
             train: "train";
             validation: "validation";
-            test: "test";
-            frozen_eval: "frozen_eval";
         }>;
         primaryMetric: z.ZodEnum<{
+            cost_usd: "cost_usd";
             foreground_tokens: "foreground_tokens";
-            success_rate: "success_rate";
             latency_ms: "latency_ms";
-            cost_usd: "cost_usd";
+            success_rate: "success_rate";
         }>;
         qualityGate: z.ZodEnum<{
-            none: "none";
-            non_regression: "non_regression";
             all_pass: "all_pass";
+            non_regression: "non_regression";
+            none: "none";
         }>;
         source: z.ZodEnum<{
             builtin: "builtin";
@@ -165,9 +166,9 @@ export declare const TasksetDraftSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     status: z.ZodEnum<{
         draft: "draft";
-        validating: "validating";
         needs_review: "needs_review";
         published: "published";
+        validating: "validating";
     }>;
     sourceRefs: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.trainingSource.v1">;
@@ -182,15 +183,15 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         occurredAt: z.ZodString;
         consent: z.ZodObject<{
             status: z.ZodEnum<{
-                pending: "pending";
-                granted: "granted";
                 denied: "denied";
+                granted: "granted";
+                pending: "pending";
                 revoked: "revoked";
             }>;
             scope: z.ZodEnum<{
+                full_session: "full_session";
                 metadata_only: "metadata_only";
                 selected_turns: "selected_turns";
-                full_session: "full_session";
             }>;
             grantedBy: z.ZodNullable<z.ZodString>;
             grantedAt: z.ZodNullable<z.ZodString>;
@@ -198,21 +199,21 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         }, z.core.$strip>;
         connectedAppIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
         secretScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
-            blocked: "blocked";
         }>;
         piiScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
             review: "review";
-            blocked: "blocked";
         }>;
         licensingStatus: z.ZodEnum<{
-            pending: "pending";
             approved: "approved";
-            review: "review";
             blocked: "blocked";
+            pending: "pending";
+            review: "review";
         }>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -222,21 +223,21 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         sourceHash: z.ZodString;
         occurredAt: z.ZodString;
         licensingStatus: z.ZodEnum<{
-            pending: "pending";
             approved: "approved";
-            review: "review";
             blocked: "blocked";
+            pending: "pending";
+            review: "review";
         }>;
         secretScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
-            blocked: "blocked";
         }>;
         piiScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
             review: "review";
-            blocked: "blocked";
         }>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         schemaVersion: z.ZodLiteral<"openpond.huggingFaceDatasetSource.v1">;
@@ -257,21 +258,21 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         sourceHash: z.ZodString;
         occurredAt: z.ZodString;
         licensingStatus: z.ZodEnum<{
-            pending: "pending";
             approved: "approved";
-            review: "review";
             blocked: "blocked";
+            pending: "pending";
+            review: "review";
         }>;
         secretScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
-            blocked: "blocked";
         }>;
         piiScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
             review: "review";
-            blocked: "blocked";
         }>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         schemaVersion: z.ZodLiteral<"openpond.uploadedFileDatasetSource.v1">;
@@ -288,21 +289,21 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         sourceHash: z.ZodString;
         occurredAt: z.ZodString;
         licensingStatus: z.ZodEnum<{
-            pending: "pending";
             approved: "approved";
-            review: "review";
             blocked: "blocked";
+            pending: "pending";
+            review: "review";
         }>;
         secretScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
-            blocked: "blocked";
         }>;
         piiScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
             review: "review";
-            blocked: "blocked";
         }>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         schemaVersion: z.ZodLiteral<"openpond.generatedDatasetSource.v1">;
@@ -318,21 +319,21 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         sourceHash: z.ZodString;
         occurredAt: z.ZodString;
         licensingStatus: z.ZodEnum<{
-            pending: "pending";
             approved: "approved";
-            review: "review";
             blocked: "blocked";
+            pending: "pending";
+            review: "review";
         }>;
         secretScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
-            blocked: "blocked";
         }>;
         piiScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
             review: "review";
-            blocked: "blocked";
         }>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         schemaVersion: z.ZodLiteral<"openpond.learningBatchDatasetSource.v1">;
@@ -357,40 +358,40 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         sourceHash: z.ZodString;
         occurredAt: z.ZodString;
         licensingStatus: z.ZodEnum<{
-            pending: "pending";
             approved: "approved";
-            review: "review";
             blocked: "blocked";
+            pending: "pending";
+            review: "review";
         }>;
         secretScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
-            blocked: "blocked";
         }>;
         piiScanStatus: z.ZodEnum<{
+            blocked: "blocked";
             passed: "passed";
             pending: "pending";
             review: "review";
-            blocked: "blocked";
         }>;
         origin: z.ZodEnum<{
+            claude_code: "claude_code";
+            codex: "codex";
+            grok_build: "grok_build";
             hermes: "hermes";
-            openclaw: "openclaw";
             native_chat: "native_chat";
             native_work: "native_work";
-            codex: "codex";
-            claude_code: "claude_code";
+            oh_my_pi: "oh_my_pi";
+            openclaw: "openclaw";
             opencode: "opencode";
-            grok_build: "grok_build";
             pi: "pi";
-            oh_my_pi: "oh_my_pi";
         }>;
         sourceId: z.ZodString;
         sessionId: z.ZodString;
         normalizerVersion: z.ZodString;
         projection: z.ZodEnum<{
-            turn: "turn";
             conversation: "conversation";
+            turn: "turn";
         }>;
         ownerUserId: z.ZodString;
         purpose: z.ZodLiteral<"recorded_evaluation">;
@@ -409,33 +410,33 @@ export declare const TasksetDraftSchema: z.ZodObject<{
             fields: z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
                 semanticRole: z.ZodEnum<{
-                    metadata: "metadata";
-                    feedback: "feedback";
-                    messages: "messages";
-                    prompt: "prompt";
-                    row_id: "row_id";
+                    chosen: "chosen";
                     cluster_id: "cluster_id";
                     demonstration: "demonstration";
-                    chosen: "chosen";
-                    rejected: "rejected";
                     expected_output: "expected_output";
+                    feedback: "feedback";
+                    messages: "messages";
+                    metadata: "metadata";
                     privileged_context: "privileged_context";
+                    prompt: "prompt";
+                    rejected: "rejected";
                     reward: "reward";
+                    row_id: "row_id";
                     tag: "tag";
                 }>;
                 logicalType: z.ZodEnum<{
-                    string: "string";
                     boolean: "boolean";
-                    messages: "messages";
-                    integer: "integer";
                     float: "float";
+                    integer: "integer";
                     json: "json";
+                    messages: "messages";
+                    string: "string";
                 }>;
                 nullable: z.ZodBoolean;
                 policy: z.ZodEnum<{
                     metadata: "metadata";
-                    visible: "visible";
                     privileged: "privileged";
+                    visible: "visible";
                 }>;
             }, z.core.$strip>>;
             schemaHash: z.ZodString;
@@ -443,10 +444,10 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         shards: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             split: z.ZodEnum<{
+                frozen_eval: "frozen_eval";
+                test: "test";
                 train: "train";
                 validation: "validation";
-                test: "test";
-                frozen_eval: "frozen_eval";
             }>;
             path: z.ZodString;
             contentHash: z.ZodString;
@@ -457,10 +458,10 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         }, z.core.$strip>>;
         rowCount: z.ZodNumber;
         splitCounts: z.ZodRecord<z.ZodEnum<{
+            frozen_eval: "frozen_eval";
+            test: "test";
             train: "train";
             validation: "validation";
-            test: "test";
-            frozen_eval: "frozen_eval";
         }>, z.ZodNumber>;
         sourceReceiptRefs: z.ZodArray<z.ZodString>;
         mappingHash: z.ZodString;
@@ -477,10 +478,10 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         protocolVersion: z.ZodLiteral<"openpond.taskEnvironment.v1">;
         kind: z.ZodEnum<{
             agent: "agent";
-            work: "work";
             chat: "chat";
             program: "program";
             stateful_harness: "stateful_harness";
+            work: "work";
         }>;
         entrypoint: z.ZodString;
         stateful: z.ZodBoolean;
@@ -512,32 +513,32 @@ export declare const TasksetDraftSchema: z.ZodObject<{
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
         lifecycle: z.ZodArray<z.ZodEnum<{
-            grade: "grade";
+            cleanup: "cleanup";
             create: "create";
+            grade: "grade";
             reset: "reset";
             step: "step";
-            cleanup: "cleanup";
         }>>;
         defaultTimeoutMs: z.ZodNumber;
         networkPolicy: z.ZodEnum<{
-            none: "none";
             declared_read_only: "declared_read_only";
             declared_scoped: "declared_scoped";
+            none: "none";
         }>;
         resources: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             kind: z.ZodEnum<{
-                file: "file";
-                configuration: "configuration";
                 catalog: "catalog";
                 code_module: "code_module";
+                configuration: "configuration";
+                file: "file";
             }>;
             path: z.ZodString;
             mediaType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             visibility: z.ZodEnum<{
-                privileged: "privileged";
-                policy_visible: "policy_visible";
                 policy_hidden: "policy_hidden";
+                policy_visible: "policy_visible";
+                privileged: "privileged";
             }>;
             required: z.ZodBoolean;
             metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -546,9 +547,9 @@ export declare const TasksetDraftSchema: z.ZodObject<{
     }, z.core.$strip>;
     output: z.ZodDefault<z.ZodObject<{
         mode: z.ZodEnum<{
-            text: "text";
-            structured_json: "structured_json";
             artifacts: "artifacts";
+            structured_json: "structured_json";
+            text: "text";
         }>;
         jsonSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         renderer: z.ZodNullable<z.ZodObject<{
@@ -561,45 +562,45 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.tasksetCapabilities.v1">;
         taskKind: z.ZodEnum<{
             chat: "chat";
-            single_agent: "single_agent";
-            multi_agent: "multi_agent";
             custom_program: "custom_program";
+            multi_agent: "multi_agent";
+            single_agent: "single_agent";
         }>;
         supportedSignals: z.ZodArray<z.ZodEnum<{
+            correction: "correction";
+            demonstration: "demonstration";
+            feedback: "feedback";
             label: "label";
             preference: "preference";
-            feedback: "feedback";
-            demonstration: "demonstration";
             reward: "reward";
-            correction: "correction";
         }>>;
         compatibleMethods: z.ZodArray<z.ZodEnum<{
-            none: "none";
-            sft: "sft";
             dpo: "dpo";
             grpo: "grpo";
-            ppo: "ppo";
-            sdft: "sdft";
+            none: "none";
             opd: "opd";
             opsd: "opsd";
-            sdpo: "sdpo";
+            ppo: "ppo";
             retrieval: "retrieval";
+            sdft: "sdft";
+            sdpo: "sdpo";
+            sft: "sft";
         }>>;
         rewardKinds: z.ZodArray<z.ZodEnum<{
-            none: "none";
-            exact: "exact";
             deterministic: "deterministic";
-            model_judge: "model_judge";
+            exact: "exact";
             human: "human";
+            model_judge: "model_judge";
+            none: "none";
         }>>;
         requiresTools: z.ZodBoolean;
         requiresState: z.ZodBoolean;
         requiresPrivilegedGrading: z.ZodBoolean;
         environmentPlacements: z.ZodArray<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
             colocated: "colocated";
+            local: "local";
             provider_native: "provider_native";
+            remote: "remote";
         }>>;
         exportable: z.ZodBoolean;
         portabilityBlockers: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -608,14 +609,14 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.tasksetMetricPolicy.v1">;
         primaryMetric: z.ZodString;
         aggregation: z.ZodEnum<{
+            custom: "custom";
             mean_score: "mean_score";
             pass_rate: "pass_rate";
             weighted_mean: "weighted_mean";
-            custom: "custom";
         }>;
         missingReward: z.ZodEnum<{
-            zero: "zero";
             exclude: "exclude";
+            zero: "zero";
         }>;
         taskWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         customAggregator: z.ZodNullable<z.ZodObject<{
@@ -645,10 +646,10 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         id: z.ZodString;
         clusterKey: z.ZodString;
         split: z.ZodEnum<{
+            frozen_eval: "frozen_eval";
+            test: "test";
             train: "train";
             validation: "validation";
-            test: "test";
-            frozen_eval: "frozen_eval";
         }>;
         input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -664,10 +665,10 @@ export declare const TasksetDraftSchema: z.ZodObject<{
             sha256: z.ZodString;
             sizeBytes: z.ZodNumber;
             split: z.ZodEnum<{
+                frozen_eval: "frozen_eval";
+                test: "test";
                 train: "train";
                 validation: "validation";
-                test: "test";
-                frozen_eval: "frozen_eval";
             }>;
             metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>>>;
@@ -676,6 +677,7 @@ export declare const TasksetDraftSchema: z.ZodObject<{
             path: z.ZodString;
             mediaType: z.ZodString;
             schemaRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
             maxBytes: z.ZodOptional<z.ZodNumber>;
             metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>>>;
@@ -694,13 +696,13 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         privileged: z.ZodDefault<z.ZodBoolean>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         kind: z.ZodEnum<{
-            file: "file";
             content: "content";
-            state: "state";
-            test: "test";
             diff: "diff";
-            schema: "schema";
+            file: "file";
             runtime_event: "runtime_event";
+            schema: "schema";
+            state: "state";
+            test: "test";
         }>;
         config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>, z.ZodObject<{
@@ -717,30 +719,30 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         rubric: z.ZodString;
         judge: z.ZodObject<{
             providerId: z.ZodUnion<readonly [z.ZodEnum<{
-                openpond: "openpond";
-                codex: "codex";
+                anthropic: "anthropic";
                 "claude-code": "claude-code";
+                codex: "codex";
+                "custom-openai-compatible": "custom-openai-compatible";
+                deepseek: "deepseek";
+                google: "google";
                 "grok-build": "grok-build";
-                opencode: "opencode";
-                anthropic: "anthropic";
+                groq: "groq";
+                moonshot: "moonshot";
                 openai: "openai";
-                xai: "xai";
-                google: "google";
+                opencode: "opencode";
+                openpond: "openpond";
                 openrouter: "openrouter";
-                deepseek: "deepseek";
-                zai: "zai";
-                moonshot: "moonshot";
                 together: "together";
-                groq: "groq";
-                "custom-openai-compatible": "custom-openai-compatible";
+                xai: "xai";
+                zai: "zai";
             }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
             modelId: z.ZodString;
         }, z.core.$strip>;
         calibrationFixtureRefs: z.ZodArray<z.ZodString>;
         calibrationStatus: z.ZodEnum<{
+            failed: "failed";
             passed: "passed";
             pending: "pending";
-            failed: "failed";
         }>;
         temperature: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
@@ -857,11 +859,11 @@ export declare const TasksetDraftSchema: z.ZodObject<{
         id: z.ZodString;
         taskId: z.ZodString;
         label: z.ZodEnum<{
+            adversarial: "adversarial";
+            boundary: "boundary";
             infrastructure_failure: "infrastructure_failure";
-            positive: "positive";
             negative: "negative";
-            boundary: "boundary";
-            adversarial: "adversarial";
+            positive: "positive";
             prompt_injection: "prompt_injection";
         }>;
         output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -921,10 +923,10 @@ export declare const TasksetDraftSchema: z.ZodObject<{
             kind: z.ZodLiteral<"feedback">;
             feedback: z.ZodString;
             polarity: z.ZodEnum<{
+                mixed: "mixed";
+                negative: "negative";
                 neutral: "neutral";
                 positive: "positive";
-                negative: "negative";
-                mixed: "mixed";
             }>;
         }, z.core.$strip>>>;
         rewards: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/dist/types/packages/sdk/src/taskset-draft-document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taskset-draft-document.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-draft-document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwCxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE9B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;EAKnC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAazC,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;iBA2B3C,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqE7B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAC1F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"taskset-draft-document.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-draft-document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwCxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE9B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;EAKnC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAazC,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;iBA2B3C,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqE7B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAC1F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}