@oneharness/sdk 0.6.14 → 0.6.16

package/dist/generated/zod.js

@@ -19,6 +19,11 @@ export const ActionEventSchema = z.looseObject({
     timing_source: z.union([z.lazy(() => TimingSourceSchema), z.null()]).optional(),
     tool_call_id: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
 });
+export const AuthModeSchema = z.union([
+    z.literal("subscription"),
+    z.literal("api_key"),
+    z.literal("unknown"),
+]);
 export const BatchReportSchema = z.looseObject({
     forked: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
     prompt_count: z
@@ -28,6 +33,46 @@ export const BatchReportSchema = z.looseObject({
     strategy: z.lazy(() => BatchStrategySchema).refine((value) => value !== undefined, { message: "Required" }),
 });
 export const BatchStrategySchema = z.union([z.literal("speed"), z.literal("min-tokens")]);
+export const ConfigOptionsSchema = z.strictObject({
+    config: z.string().optional(),
+    cwd: z.string().optional(),
+    noConfig: z.boolean().optional(),
+});
+export const ConfigReportSchema = z.looseObject({
+    all: z.lazy(() => FieldSchema).refine((value) => value !== undefined, { message: "Required" }),
+    allowed_tools: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    bypass: z.lazy(() => FieldSchema).refine((value) => value !== undefined, { message: "Required" }),
+    config_files: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+    denied_tools: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    env: z
+        .record(z.string(), z.lazy(() => Field3Schema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    exclude: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    harness: z
+        .record(z.string(), z.lazy(() => HarnessReportSchema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    harnesses: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    history: z.lazy(() => FieldSchema).refine((value) => value !== undefined, { message: "Required" }),
+    history_dir: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    history_labels: z
+        .record(z.string(), z.lazy(() => Field3Schema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    hooks: z.lazy(() => Field10Schema).refine((value) => value !== undefined, { message: "Required" }),
+    max_parallel: z.lazy(() => Field8Schema).refine((value) => value !== undefined, { message: "Required" }),
+    mode: z.lazy(() => Field4Schema).refine((value) => value !== undefined, { message: "Required" }),
+    model: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    models: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    output_format: z.lazy(() => Field6Schema).refine((value) => value !== undefined, { message: "Required" }),
+    reasoning: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    require_available: z.lazy(() => FieldSchema).refine((value) => value !== undefined, { message: "Required" }),
+    run_mode: z.lazy(() => Field9Schema).refine((value) => value !== undefined, { message: "Required" }),
+    schema_file: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    schema_max_retries: z.lazy(() => Field7Schema).refine((value) => value !== undefined, { message: "Required" }),
+    schema_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    stream: z.lazy(() => FieldSchema).refine((value) => value !== undefined, { message: "Required" }),
+    system: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    timeout: z.lazy(() => Field5Schema).refine((value) => value !== undefined, { message: "Required" }),
+});
 export const ControlEventSchema = z.union([
     z.looseObject({
         at: z.lazy(() => UtcInstantSchema).refine((value) => value !== undefined, { message: "Required" }),
@@ -67,6 +112,15 @@ export const DetectInfoSchema = z.looseObject({
     path: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
     version: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
 });
+export const DetectOptionsSchema = z.strictObject({
+    all: z.boolean().optional(),
+    bins: z.record(z.string(), z.string()).optional(),
+    config: z.string().optional(),
+    exclude: z.array(z.string()).optional(),
+    harnesses: z.array(z.string()).optional(),
+    noConfig: z.boolean().optional(),
+    requireAvailable: z.boolean().optional(),
+});
 export const DetectReportSchema = z.looseObject({
     detected: z.array(z.lazy(() => DetectInfoSchema)).refine((value) => value !== undefined, { message: "Required" }),
     schema_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
@@ -126,6 +180,68 @@ export const FallbackReportSchema = z.looseObject({
         .refine((value) => value !== undefined, { message: "Required" }),
     ran: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
 });
+export const FieldSchema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z.union([z.boolean(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field10Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z
+        .union([z.array(z.lazy(() => HookEntrySchema)), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field2Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z.union([z.array(z.string()), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field3Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field4Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z
+        .union([z.lazy(() => PermissionModeSchema), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field5Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field6Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z
+        .union([z.lazy(() => OutputFormatSchema), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field7Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field8Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const Field9Schema = z.looseObject({
+    source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    value: z
+        .union([z.lazy(() => RunModeSchema), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const FileStatusSchema = z.union([
+    z.literal("created"),
+    z.literal("updated"),
+    z.literal("unchanged"),
+]);
+export const GateOptionsSchema = z.strictObject({
+    denyIfContains: z.string().optional(),
+    event: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    harness: z
+        .string()
+        .min(1)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    reason: z.string().optional(),
+});
 export const HarnessInfoSchema = z.looseObject({
     control: z
         .union([z.lazy(() => ControlShapeSchema), z.null()])
@@ -153,6 +269,51 @@ export const HarnessInfoSchema = z.looseObject({
     sync_file: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
     variants: z.array(z.lazy(() => VariantInfoSchema)).refine((value) => value !== undefined, { message: "Required" }),
 });
+export const HarnessReportSchema = z.looseObject({
+    allowed_tools: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    args: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    bin: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    denied_tools: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    env: z
+        .record(z.string(), z.lazy(() => Field3Schema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    hooks: z.looseObject({}).refine((value) => value !== undefined, { message: "Required" }),
+    model: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    reasoning: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    settings: z.looseObject({}).refine((value) => value !== undefined, { message: "Required" }),
+    variant: z
+        .record(z.string(), z.lazy(() => VariantReportSchema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const HistoryClearDryRunSchema = z.looseObject({
+    dry_run: z.literal(true).refine((value) => value !== undefined, { message: "Required" }),
+    files: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+    hint: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    would_remove: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const HistoryClearOptionsSchema = z.strictObject({
+    allProjects: z.boolean().optional(),
+    config: z.string().optional(),
+    historyDir: z.string().optional(),
+    noConfig: z.boolean().optional(),
+    project: z.string().optional(),
+    yes: z.boolean().optional(),
+});
+export const HistoryClearRemovedSchema = z.looseObject({
+    dry_run: z.literal(false).refine((value) => value !== undefined, { message: "Required" }),
+    files: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+    removed: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const HistoryClearReportSchema = z.union([
+    z.lazy(() => HistoryClearRemovedSchema),
+    z.lazy(() => HistoryClearDryRunSchema),
+]);
 export const HistoryEventLineSchema = z.union([
     z.looseObject({
         event: z.lazy(() => ActionEventSchema).refine((value) => value !== undefined, { message: "Required" }),
@@ -726,30 +887,51 @@ export const HistoryLineSchema = z.union([
 export const HistoryListSchema = z.array(z.lazy(() => HistorySessionSummarySchema));
 export const HistoryListOptionsSchema = z.strictObject({
     allProjects: z.boolean().optional(),
+    config: z.string().optional(),
     historyDir: z.string().optional(),
+    noConfig: z.boolean().optional(),
     project: z.string().optional(),
+    variant: z.string().optional(),
 });
 export const HistoryLookupSchema = z.union([
     z.lazy(() => HistoryLookupByLastSchema),
     z.lazy(() => HistoryLookupBySessionSchema),
 ]);
 export const HistoryLookupByLastSchema = z.strictObject({
+    all: z.boolean().optional(),
     allProjects: z.boolean().optional(),
+    config: z.string().optional(),
     historyDir: z.string().optional(),
     last: z.literal(true).refine((value) => value !== undefined, { message: "Required" }),
+    noConfig: z.boolean().optional(),
     project: z.string().optional(),
     session: z.string().optional(),
 });
 export const HistoryLookupBySessionSchema = z.strictObject({
+    all: z.boolean().optional(),
     allProjects: z.boolean().optional(),
+    config: z.string().optional(),
     historyDir: z.string().optional(),
     last: z.boolean().optional(),
+    noConfig: z.boolean().optional(),
     project: z.string().optional(),
     session: z
         .string()
         .min(1)
         .refine((value) => value !== undefined, { message: "Required" }),
 });
+export const HistoryMigrateOptionsSchema = z.strictObject({
+    config: z.string().optional(),
+    historyDir: z.string().optional(),
+    noConfig: z.boolean().optional(),
+});
+export const HistoryMigrateReportSchema = z.looseObject({
+    files: z.array(z.lazy(() => MigrationSummarySchema)).refine((value) => value !== undefined, { message: "Required" }),
+    files_processed: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
 export const HistoryRecordSchema = z.intersection(z.intersection(z.intersection(z.union([
     z.looseObject({
         duration_ms: z
@@ -1570,15 +1752,98 @@ export const HistoryWatchOptionsSchema = z.strictObject({
         .refine((value) => [...value].length <= 36, { message: "Too long: expected at most 36 characters" })
         .optional(),
     allProjects: z.boolean().optional(),
+    config: z.string().optional(),
     events: z.boolean().optional(),
     historyDir: z.string().optional(),
     labels: z.lazy(() => HistoryLabelsSchema).optional(),
+    noConfig: z.boolean().optional(),
     project: z.string().optional(),
+    variant: z.string().optional(),
+});
+export const HookEntrySchema = z.strictObject({
+    command: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    harnesses: z.union([z.array(z.string()), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    matcher: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    plugin_name: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    timeout: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
 });
+export const HookFileResultSchema = z.looseObject({
+    file: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    status: z.lazy(() => FileStatusSchema).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const IdentitySelectorSchema = z.union([
+    z.looseObject({
+        env: z.string().refine((value) => value !== undefined, { message: "Required" }),
+        kind: z.literal("env_path").refine((value) => value !== undefined, { message: "Required" }),
+        path: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        env: z.string().refine((value) => value !== undefined, { message: "Required" }),
+        kind: z.literal("env_secret").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        kind: z.literal("ambient").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+]);
+export const InitOptionsSchema = z.strictObject({
+    force: z.boolean().optional(),
+    path: z.string().optional(),
+});
+export const InterruptOptionsSchema = z.strictObject({
+    cwd: z.string().optional(),
+    input: z.string().optional(),
+    session: z
+        .string()
+        .min(1)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    sessionDir: z.string().optional(),
+});
+export const InterruptResponseSchema = z.union([
+    z.looseObject({
+        error: z.never().optional(),
+        mechanism: z.lazy(() => ControlShapeSchema).refine((value) => value !== undefined, { message: "Required" }),
+        ok: z.literal(true).refine((value) => value !== undefined, { message: "Required" }),
+        reason: z.never().optional(),
+        redirected: z.boolean().optional(),
+        v: z.literal(2).refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        error: z.string().refine((value) => value !== undefined, { message: "Required" }),
+        mechanism: z.never().optional(),
+        ok: z.literal(false).refine((value) => value !== undefined, { message: "Required" }),
+        reason: z.lazy(() => ControlReasonSchema).refine((value) => value !== undefined, { message: "Required" }),
+        redirected: z.literal(false).optional(),
+        v: z.literal(2).refine((value) => value !== undefined, { message: "Required" }),
+    }),
+]);
 export const ListReportSchema = z.looseObject({
     harnesses: z.array(z.lazy(() => HarnessInfoSchema)).refine((value) => value !== undefined, { message: "Required" }),
     schema_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
 });
+export const MigrationSummarySchema = z.looseObject({
+    already_current: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    path: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    records_migrated: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    skipped: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const MockOptionsSchema = z.strictObject({
+    event: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    harness: z
+        .string()
+        .min(1)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    rules: z.string().optional(),
+    spyFile: z.string().optional(),
+});
 export const ModeHeadlessSchema = z.union([z.literal("clean"), z.literal("hangs")]);
 export const ModeInfoSchema = z.looseObject({
     headless: z.lazy(() => ModeHeadlessSchema).refine((value) => value !== undefined, { message: "Required" }),
@@ -1597,27 +1862,62 @@ export const PermissionModeSchema = z.union([
     z.literal("auto"),
     z.literal("bypass"),
 ]);
+export const QuotaAmountSchema = z.int().gte(0);
+export const QuotaCountersSchema = z.looseObject({
+    entitlement: z.lazy(() => QuotaAmountSchema).refine((value) => value !== undefined, { message: "Required" }),
+    has_quota: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    overage_permitted: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    remaining: z.int().refine((value) => value !== undefined, { message: "Required" }),
+    unit: z.lazy(() => QuotaUnitSchema).refine((value) => value !== undefined, { message: "Required" }),
+    used: z.lazy(() => QuotaAmountSchema).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const QuotaUnitSchema = z.union([z.literal("ai_credits"), z.literal("unspecified")]);
+export const RunModeSchema = z.union([z.literal("parallel"), z.literal("fallback")]);
 export const RunOptionsSchema = z.strictObject({
+    all: z.boolean().optional(),
+    batchPrompts: z.array(z.string()).optional(),
+    batchStrategy: z.lazy(() => BatchStrategySchema).optional(),
     bins: z.record(z.string(), z.string()).optional(),
+    config: z.string().optional(),
+    control: z.boolean().optional(),
     cwd: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),
     events: z.boolean().optional(),
+    exclude: z.array(z.string()).optional(),
     fork: z.boolean().optional(),
     harnesses: z.array(z.string()).optional(),
     history: z.boolean().optional(),
     historyDir: z.string().optional(),
     historyLabels: z.lazy(() => HistoryLabelsSchema).optional(),
     historyName: z.string().optional(),
+    maxParallel: z.int().gte(0).optional(),
+    mockHarnesses: z.array(z.string()).optional(),
+    mockRules: z.string().optional(),
     mode: z.lazy(() => PermissionModeSchema).optional(),
     models: z.array(z.string()).optional(),
+    noConfig: z.boolean().optional(),
+    noHistory: z.boolean().optional(),
+    outputDir: z.string().optional(),
+    outputFormat: z.lazy(() => OutputFormatSchema).optional(),
+    passthrough: z.array(z.string()).optional(),
+    permitPrompts: z.boolean().optional(),
+    printCommand: z.boolean().optional(),
     prompt: z
         .string()
         .min(1)
         .refine((value) => value !== undefined, { message: "Required" }),
+    promptFiles: z.array(z.string()).optional(),
     reasoning: z.string().optional(),
+    requireAvailable: z.boolean().optional(),
     resume: z.string().optional(),
+    runMode: z.lazy(() => RunModeSchema).optional(),
+    schema: z.string().optional(),
+    schemaMaxRetries: z.int().gte(0).optional(),
     session: z.string().optional(),
+    sessionDir: z.string().optional(),
+    spyFile: z.string().optional(),
     system: z.string().optional(),
+    systemFile: z.string().optional(),
     timeoutSeconds: z.int().gte(0).optional(),
 });
 export const RunReportSchema = z.looseObject({
@@ -1716,6 +2016,33 @@ export const StatusSchema = z.union([
     z.literal("skipped"),
     z.literal("planned"),
 ]);
+export const SyncOptionsSchema = z.strictObject({
+    check: z.boolean().optional(),
+    config: z.string().optional(),
+    cwd: z.string().optional(),
+    global: z.boolean().optional(),
+    harnesses: z.array(z.string()).optional(),
+    noConfig: z.boolean().optional(),
+});
+export const SyncReportSchema = z.looseObject({
+    check: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    config_files: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+    results: z.array(z.lazy(() => SyncResultSchema)).refine((value) => value !== undefined, { message: "Required" }),
+    schema_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
+});
+export const SyncResultSchema = z.looseObject({
+    file: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    harness: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    hooks: z.array(z.lazy(() => HookFileResultSchema)).refine((value) => value !== undefined, { message: "Required" }),
+    status: z.lazy(() => SyncStatusSchema).refine((value) => value !== undefined, { message: "Required" }),
+    unmapped: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const SyncStatusSchema = z.union([
+    z.literal("created"),
+    z.literal("updated"),
+    z.literal("unchanged"),
+    z.literal("skipped"),
+]);
 export const TimingSourceSchema = z.union([
     z.literal("provider_measured"),
     z.literal("stdout_observed"),
@@ -1726,6 +2053,26 @@ export const ToolCallStatusSchema = z.union([
     z.literal("timeout"),
     z.literal("interrupted"),
 ]);
+export const UnavailableReasonSchema = z.union([
+    z.literal("api_key_auth"),
+    z.literal("not_logged_in"),
+    z.literal("no_windows_reported"),
+    z.literal("no_plan_quota"),
+    z.literal("no_headroom_reader"),
+]);
+export const UnknownReasonSchema = z.union([
+    z.looseObject({
+        kind: z.literal("unprobed").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        kind: z.literal("probe_failed").refine((value) => value !== undefined, { message: "Required" }),
+        message: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        bin: z.string().refine((value) => value !== undefined, { message: "Required" }),
+        kind: z.literal("binary_missing").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+]);
 export const UsageSchema = z.looseObject({
     cache_read_tokens: z
         .union([z.int().gte(0), z.null()])
@@ -1737,6 +2084,74 @@ export const UsageSchema = z.looseObject({
     input_tokens: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
     output_tokens: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
 });
+export const UsageAvailabilitySchema = z.union([
+    z.looseObject({
+        state: z.literal("available").refine((value) => value !== undefined, { message: "Required" }),
+        windows: z.lazy(() => WindowsSchema).refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        reason: z.lazy(() => UnavailableReasonSchema).refine((value) => value !== undefined, { message: "Required" }),
+        state: z.literal("unavailable").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        reason: z.lazy(() => UnknownReasonSchema).refine((value) => value !== undefined, { message: "Required" }),
+        state: z.literal("unknown").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+]);
+export const UsageIdentitySchema = z.looseObject({
+    auth_mode: z.lazy(() => AuthModeSchema).refine((value) => value !== undefined, { message: "Required" }),
+    availability: z.lazy(() => UsageAvailabilitySchema).refine((value) => value !== undefined, { message: "Required" }),
+    harness: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    plan: z.union([z.string(), z.null()]).optional(),
+    selector: z.lazy(() => IdentitySelectorSchema).refine((value) => value !== undefined, { message: "Required" }),
+    variant: z.union([z.string(), z.null()]).optional(),
+});
+export const UsageOptionsSchema = z.strictObject({
+    all: z.boolean().optional(),
+    bins: z.record(z.string(), z.string()).optional(),
+    config: z.string().optional(),
+    cwd: z.string().optional(),
+    exclude: z.array(z.string()).optional(),
+    harnesses: z.array(z.string()).optional(),
+    noConfig: z.boolean().optional(),
+    timeoutSeconds: z.int().gte(0).optional(),
+});
+export const UsageReportSchema = z.looseObject({
+    identities: z
+        .array(z.lazy(() => UsageIdentitySchema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    observed_at: z.lazy(() => UtcInstantSchema).refine((value) => value !== undefined, { message: "Required" }),
+    schema_version: z.literal("0.1").refine((value) => value !== undefined, { message: "Required" }),
+});
+export const UsageWindowSchema = z.intersection(z.looseObject({
+    id: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    is_binding: z.union([z.boolean(), z.null()]).optional(),
+    label: z.union([z.string(), z.null()]).optional(),
+    resets_at: z.union([z.lazy(() => UtcInstantSchema), z.null()]).optional(),
+    scope: z.union([z.string(), z.null()]).optional(),
+    usage: z.lazy(() => WindowUsageSchema).refine((value) => value !== undefined, { message: "Required" }),
+}), z.union([
+    z.looseObject({
+        window_seconds: z
+            .int()
+            .gte(1)
+            .refine((value) => value !== undefined, { message: "Required" }),
+        window_seconds_source: z.literal("reported").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        window_seconds: z
+            .int()
+            .gte(1)
+            .refine((value) => value !== undefined, { message: "Required" }),
+        window_seconds_source: z
+            .literal("inferred_from_id")
+            .refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        window_seconds_source: z.literal("unknown").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+]));
+export const UsedPercentSchema = z.number().gte(0);
 export const UtcInstantSchema = z.string();
 export const VariantInfoSchema = z.looseObject({
     args: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
@@ -1749,3 +2164,32 @@ export const VariantInfoSchema = z.looseObject({
     name: z.string().refine((value) => value !== undefined, { message: "Required" }),
     unset_env: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
 });
+export const VariantReportSchema = z.looseObject({
+    allowed_tools: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    args: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    bin: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    denied_tools: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+    env: z
+        .record(z.string(), z.lazy(() => Field3Schema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    env_file: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    env_from: z
+        .record(z.string(), z.lazy(() => Field3Schema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    hooks: z.looseObject({}).refine((value) => value !== undefined, { message: "Required" }),
+    model: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    reasoning: z.lazy(() => Field3Schema).refine((value) => value !== undefined, { message: "Required" }),
+    settings: z.looseObject({}).refine((value) => value !== undefined, { message: "Required" }),
+    unset_env: z.lazy(() => Field2Schema).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const WindowUsageSchema = z.union([
+    z.looseObject({
+        counters: z.union([z.lazy(() => QuotaCountersSchema), z.null()]).optional(),
+        kind: z.literal("metered").refine((value) => value !== undefined, { message: "Required" }),
+        used_percent: z.lazy(() => UsedPercentSchema).refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.looseObject({
+        kind: z.literal("unlimited").refine((value) => value !== undefined, { message: "Required" }),
+    }),
+]);
+export const WindowsSchema = z.array(z.lazy(() => UsageWindowSchema));