veryfront 0.1.501 → 0.1.503

package/src/src/jobs/schemas.ts

@@ -1,303 +1,420 @@
-import { z } from "zod";
-
-export const JobStatusSchema = z.enum([
-  "submitted",
-  "working",
-  "completed",
-  "failed",
-  "canceled",
-]);
-
-export const CronJobStatusSchema = z.enum(["active", "paused", "deleting"]);
-export const JobKindSchema = z.enum(["knowledge_ingest"]).nullable();
-
-export const ReservedJobTargetFamilySchema = z.enum(["task:*", "workflow:*", "deploy:*"]);
-
-export const PageInfoSchema = z.object({
-  self: z.string().nullable(),
-  first: z.literal(null),
-  next: z.string().nullable(),
-  prev: z.string().nullable(),
-});
-
-const JsonObjectSchema = z.record(z.string(), z.unknown());
-const KnowledgeIngestSkipReasonSchema = z.enum([
-  "hidden_path",
-  "ignored_directory",
-  "unsupported_file_type",
-]);
-const KnowledgeIngestFailureReasonSchema = z.enum(["parser_error", "upload_error"]);
-
-export const KnowledgeIngestFileResultSchema = z.object({
-  source: z.string(),
-  localSourcePath: z.string(),
-  outputPath: z.string(),
-  remotePath: z.string(),
-  slug: z.string(),
-  sourceType: z.string(),
-  summary: z.string(),
-  stats: JsonObjectSchema,
-  warnings: z.array(z.string()),
-});
-
-export const KnowledgeIngestSkippedFileResultSchema = z.object({
-  source: z.string(),
-  localSourcePath: z.string().nullable(),
-  reason: KnowledgeIngestSkipReasonSchema,
-  message: z.string(),
-});
-
-export const KnowledgeIngestFailedFileResultSchema = z.object({
-  source: z.string(),
-  localSourcePath: z.string(),
-  reason: KnowledgeIngestFailureReasonSchema,
-  message: z.string(),
-});
-
-export const KnowledgeIngestJobResultMetadataSchema = z.object({
-  requested_count: z.number().int().nonnegative(),
-  source_mode: z.enum(["explicit_sources", "path_prefix"]),
-  knowledge_path: z.string(),
-});
-
-export const KnowledgeIngestJobResultCountsSchema = z.object({
-  requested_count: z.number().int().nonnegative(),
-  ingested_count: z.number().int().nonnegative(),
-  skipped_count: z.number().int().nonnegative(),
-  failed_count: z.number().int().nonnegative(),
-});
-
-export const KnowledgeIngestJobResultSchema = z.object({
-  kind: z.literal("knowledge_ingest"),
-  version: z.literal(1),
-  metadata: KnowledgeIngestJobResultMetadataSchema,
-  summary: KnowledgeIngestJobResultCountsSchema,
-  ingested: z.array(KnowledgeIngestFileResultSchema),
-  skipped: z.array(KnowledgeIngestSkippedFileResultSchema),
-  failed: z.array(KnowledgeIngestFailedFileResultSchema),
-});
-
-export const JobResultSchema = z
-  .discriminatedUnion("kind", [
-    KnowledgeIngestJobResultSchema,
-    z.object({
-      kind: z.literal("value"),
-      value: z.unknown(),
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema, SchemaValidator } from "../extensions/schema/index.js";
+
+export const getJobStatusSchema = defineSchema((v) =>
+  v.enum(
+    [
+      "submitted",
+      "working",
+      "completed",
+      "failed",
+      "canceled",
+    ] as const,
+  )
+);
+
+export const getCronJobStatusSchema = defineSchema((v) =>
+  v.enum(["active", "paused", "deleting"] as const)
+);
+
+export const getJobKindSchema = defineSchema((v) =>
+  v.enum(["knowledge_ingest"] as const).nullable()
+);
+
+export const getReservedJobTargetFamilySchema = defineSchema((v) =>
+  v.enum(["task:*", "workflow:*", "deploy:*"] as const)
+);
+
+export const getPageInfoSchema = defineSchema((v) =>
+  v.object({
+    self: v.string().nullable(),
+    first: v.literal(null),
+    next: v.string().nullable(),
+    prev: v.string().nullable(),
+  })
+);
+
+// Internal helper schemas (not exported as getters)
+const jsonObjectSchema = (v: SchemaValidator) => v.record(v.string(), v.unknown());
+
+const knowledgeIngestSkipReasonSchema = (v: SchemaValidator) =>
+  v.enum(
+    [
+      "hidden_path",
+      "ignored_directory",
+      "unsupported_file_type",
+    ] as const,
+  );
+
+const knowledgeIngestFailureReasonSchema = (v: SchemaValidator) =>
+  v.enum(["parser_error", "upload_error"] as const);
+
+export const getKnowledgeIngestFileResultSchema = defineSchema((v) =>
+  v.object({
+    source: v.string(),
+    localSourcePath: v.string(),
+    outputPath: v.string(),
+    remotePath: v.string(),
+    slug: v.string(),
+    sourceType: v.string(),
+    summary: v.string(),
+    stats: jsonObjectSchema(v),
+    warnings: v.array(v.string()),
+  })
+);
+
+export const getKnowledgeIngestSkippedFileResultSchema = defineSchema((v) =>
+  v.object({
+    source: v.string(),
+    localSourcePath: v.string().nullable(),
+    reason: knowledgeIngestSkipReasonSchema(v),
+    message: v.string(),
+  })
+);
+
+export const getKnowledgeIngestFailedFileResultSchema = defineSchema((v) =>
+  v.object({
+    source: v.string(),
+    localSourcePath: v.string(),
+    reason: knowledgeIngestFailureReasonSchema(v),
+    message: v.string(),
+  })
+);
+
+export const getKnowledgeIngestJobResultMetadataSchema = defineSchema((v) =>
+  v.object({
+    requested_count: v.number().int().nonnegative(),
+    source_mode: v.enum(["explicit_sources", "path_prefix"] as const),
+    knowledge_path: v.string(),
+  })
+);
+
+export const getKnowledgeIngestJobResultCountsSchema = defineSchema((v) =>
+  v.object({
+    requested_count: v.number().int().nonnegative(),
+    ingested_count: v.number().int().nonnegative(),
+    skipped_count: v.number().int().nonnegative(),
+    failed_count: v.number().int().nonnegative(),
+  })
+);
+
+export const getKnowledgeIngestJobResultSchema = defineSchema((v) =>
+  v.object({
+    kind: v.literal("knowledge_ingest"),
+    version: v.literal(1),
+    metadata: getKnowledgeIngestJobResultMetadataSchema(),
+    summary: getKnowledgeIngestJobResultCountsSchema(),
+    ingested: v.array(getKnowledgeIngestFileResultSchema()),
+    skipped: v.array(getKnowledgeIngestSkippedFileResultSchema()),
+    failed: v.array(getKnowledgeIngestFailedFileResultSchema()),
+  })
+);
+
+export const getJobResultSchema = defineSchema((v) =>
+  v
+    .discriminatedUnion("kind", [
+      getKnowledgeIngestJobResultSchema(),
+      v.object({
+        kind: v.literal("value"),
+        value: v.unknown(),
+      }),
+      v.object({
+        kind: v.literal("artifacts"),
+        artifacts: v.array(v.unknown()),
+      }),
+    ])
+    .nullable()
+);
+
+export const getJobResultSummarySchema = defineSchema((v) =>
+  v
+    .discriminatedUnion("kind", [
+      v.object({
+        kind: v.literal("knowledge_ingest"),
+        state: v.enum(["success", "partial_success", "failed"] as const),
+        requested_count: v.number().int().nonnegative(),
+        ingested_count: v.number().int().nonnegative(),
+        skipped_count: v.number().int().nonnegative(),
+        failed_count: v.number().int().nonnegative(),
+      }),
+      v.object({
+        kind: v.literal("value"),
+      }),
+      v.object({
+        kind: v.literal("artifacts"),
+        artifact_count: v.number().int().nonnegative(),
+      }),
+    ])
+    .nullable()
+);
+
+const getBaseJobSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().uuid(),
+    project_id: v.string().uuid(),
+    environment_id: v.string().uuid().nullable(),
+    branch_id: v.string().nullable().optional(),
+    cron_job_id: v.string().uuid().nullable(),
+    batch_id: v.string().uuid().nullable(),
+    name: v.string(),
+    status: getJobStatusSchema(),
+    target: v.string(),
+    config: jsonObjectSchema(v),
+    context_id: v.string().uuid().nullable(),
+    timeout_seconds: v.number(),
+    backoff_limit: v.number(),
+    exit_code: v.number().nullable(),
+    started_at: v.string().nullable(),
+    completed_at: v.string().nullable(),
+    created_by: v.string().uuid().nullable(),
+    created_at: v.string(),
+    updated_at: v.string(),
+  })
+);
+
+export const getJobSchema = defineSchema((_v) =>
+  getBaseJobSchema().extend({
+    failed_reason: _v.string().nullable().optional(),
+    kind: getJobKindSchema().optional().default(null),
+    failure_detail: _v.string().nullable().optional().default(null),
+    result_summary: getJobResultSummarySchema().optional().default(null),
+    result: getJobResultSchema().optional().default(null),
+  })
+);
+
+export const getJobListItemSchema = defineSchema((_v) =>
+  getBaseJobSchema().extend({
+    kind: getJobKindSchema().optional().default(null),
+    failure_detail: _v.string().nullable().optional().default(null),
+    result_summary: getJobResultSummarySchema().optional().default(null),
+  })
+);
+
+export const getPaginatedJobsResponseSchema = defineSchema((v) =>
+  v.object({
+    data: v.array(getJobListItemSchema()),
+    page_info: getPageInfoSchema(),
+  })
+);
+
+export const getJobEventSchema = defineSchema((v) =>
+  v.object({
+    timestamp: v.string(),
+    level: v.string(),
+    message: v.string(),
+    service: v.string(),
+    trace_id: v.string().optional(),
+    request_id: v.string().optional(),
+    metadata: v.record(v.string(), v.string()).optional(),
+  })
+);
+
+export const getJobEventsResponseSchema = defineSchema((v) =>
+  v.object({
+    entries: v.array(getJobEventSchema()),
+    next_cursor: v.string().nullable(),
+    stats: v.object({
+      bytes_processed: v.number(),
+      lines_processed: v.number(),
+      query_time_ms: v.number(),
     }),
-    z.object({
-      kind: z.literal("artifacts"),
-      artifacts: z.array(z.unknown()),
-    }),
-  ])
-  .nullable();
-
-export const JobResultSummarySchema = z
-  .discriminatedUnion("kind", [
-    z.object({
-      kind: z.literal("knowledge_ingest"),
-      state: z.enum(["success", "partial_success", "failed"]),
-      requested_count: z.number().int().nonnegative(),
-      ingested_count: z.number().int().nonnegative(),
-      skipped_count: z.number().int().nonnegative(),
-      failed_count: z.number().int().nonnegative(),
-    }),
-    z.object({
-      kind: z.literal("value"),
-    }),
-    z.object({
-      kind: z.literal("artifacts"),
-      artifact_count: z.number().int().nonnegative(),
-    }),
-  ])
-  .nullable();
-
-const BaseJobSchema = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  environment_id: z.string().uuid().nullable(),
-  branch_id: z.string().nullable().optional(),
-  cron_job_id: z.string().uuid().nullable(),
-  batch_id: z.string().uuid().nullable(),
-  name: z.string(),
-  status: JobStatusSchema,
-  target: z.string(),
-  config: JsonObjectSchema,
-  context_id: z.string().uuid().nullable(),
-  timeout_seconds: z.number(),
-  backoff_limit: z.number(),
-  exit_code: z.number().nullable(),
-  started_at: z.string().nullable(),
-  completed_at: z.string().nullable(),
-  created_by: z.string().uuid().nullable(),
-  created_at: z.string(),
-  updated_at: z.string(),
-});
-
-export const JobSchema = BaseJobSchema.extend({
-  failed_reason: z.string().nullable().optional(),
-  kind: JobKindSchema.optional().default(null),
-  failure_detail: z.string().nullable().optional().default(null),
-  result_summary: JobResultSummarySchema.optional().default(null),
-  result: JobResultSchema.optional().default(null),
-});
-
-export const JobListItemSchema = BaseJobSchema.extend({
-  kind: JobKindSchema.optional().default(null),
-  failure_detail: z.string().nullable().optional().default(null),
-  result_summary: JobResultSummarySchema.optional().default(null),
-});
-
-export const PaginatedJobsResponseSchema = z.object({
-  data: z.array(JobListItemSchema),
-  page_info: PageInfoSchema,
-});
-
-export const JobEventSchema = z.object({
-  timestamp: z.string(),
-  level: z.string(),
-  message: z.string(),
-  service: z.string(),
-  trace_id: z.string().optional(),
-  request_id: z.string().optional(),
-  metadata: z.record(z.string(), z.string()).optional(),
-});
-
-export const JobEventsResponseSchema = z.object({
-  entries: z.array(JobEventSchema),
-  next_cursor: z.string().nullable(),
-  stats: z.object({
-    bytes_processed: z.number(),
-    lines_processed: z.number(),
-    query_time_ms: z.number(),
-  }),
-});
-
-export const JobLogsResponseSchema = z.object({
-  logs: z.string().nullable(),
-});
-
-export const KnowledgeIngestBatchSourceSchema = z.object({
-  label: z.string(),
-  path: z.string().nullable(),
-  upload_id: z.string().uuid().nullable(),
-  remote_path: z.string().nullable(),
-  warning_count: z.number().int().nonnegative(),
-});
-
-export const KnowledgeIngestBatchSourceWithMessageSchema = KnowledgeIngestBatchSourceSchema.extend({
-  message: z.string(),
-});
-
-export const JobBatchStatusCountsSchema = z.object({
-  submitted: z.number().int().nonnegative(),
-  working: z.number().int().nonnegative(),
-  completed: z.number().int().nonnegative(),
-  failed: z.number().int().nonnegative(),
-  canceled: z.number().int().nonnegative(),
-});
-
-export const JobBatchResultSchema = z
-  .discriminatedUnion("kind", [
-    z.object({
-      kind: z.literal("knowledge_ingest"),
-      total_count: z.number().int().nonnegative(),
-      completed_count: z.number().int().nonnegative(),
-      skipped_count: z.number().int().nonnegative(),
-      failed_count: z.number().int().nonnegative(),
-      processing: z.array(KnowledgeIngestBatchSourceSchema),
-      completed: z.array(KnowledgeIngestBatchSourceSchema),
-      skipped: z.array(KnowledgeIngestBatchSourceWithMessageSchema),
-      failed: z.array(KnowledgeIngestBatchSourceWithMessageSchema),
-      remaining: z.array(KnowledgeIngestBatchSourceSchema),
-      remaining_label: z.enum(["Remaining Files", "Not Ingested Files"]),
-    }),
-  ])
-  .nullable();
-
-export const JobBatchSchema = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  target: z.string().nullable(),
-  job_count: z.number().int().nonnegative(),
-  status_counts: JobBatchStatusCountsSchema,
-  created_at: z.string(),
-  updated_at: z.string(),
-  result: JobBatchResultSchema,
-});
-
-export const JobTargetDefinitionSchema = z.object({
-  target: z.string(),
-  family: z.string(),
-  description: z.string(),
-  input_schema: JsonObjectSchema,
-  output_schema: JsonObjectSchema.nullable(),
-});
-
-export const JobTargetDefinitionsResponseSchema = z.object({
-  reserved_families: z.array(ReservedJobTargetFamilySchema),
-  data: z.array(JobTargetDefinitionSchema),
-});
-
-export const CronJobSchema = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  environment_id: z.string().uuid().nullable(),
-  branch_id: z.string().nullable().optional(),
-  name: z.string(),
-  status: CronJobStatusSchema,
-  target: z.string(),
-  schedule: z.string(),
-  timezone: z.string(),
-  config: JsonObjectSchema,
-  timeout_seconds: z.number(),
-  backoff_limit: z.number(),
-  concurrency_policy: z.string(),
-  last_scheduled_at: z.string().nullable(),
-  last_successful_at: z.string().nullable(),
-  created_by: z.string().uuid().nullable(),
-  created_at: z.string(),
-  updated_at: z.string(),
-});
-
-export const PaginatedCronJobsResponseSchema = z.object({
-  data: z.array(CronJobSchema),
-  page_info: PageInfoSchema,
-});
-
-export type JobStatus = z.infer<typeof JobStatusSchema>;
-export type CronJobStatus = z.infer<typeof CronJobStatusSchema>;
-export type JobKind = z.infer<typeof JobKindSchema>;
-export type ReservedJobTargetFamily = z.infer<typeof ReservedJobTargetFamilySchema>;
-
-export type KnowledgeIngestFileResult = z.infer<typeof KnowledgeIngestFileResultSchema>;
-export type KnowledgeIngestSkippedFileResult = z.infer<
-  typeof KnowledgeIngestSkippedFileResultSchema
+  })
+);
+
+export const getJobLogsResponseSchema = defineSchema((v) =>
+  v.object({
+    logs: v.string().nullable(),
+  })
+);
+
+export const getKnowledgeIngestBatchSourceSchema = defineSchema((v) =>
+  v.object({
+    label: v.string(),
+    path: v.string().nullable(),
+    upload_id: v.string().uuid().nullable(),
+    remote_path: v.string().nullable(),
+    warning_count: v.number().int().nonnegative(),
+  })
+);
+
+export const getKnowledgeIngestBatchSourceWithMessageSchema = defineSchema((_v) =>
+  getKnowledgeIngestBatchSourceSchema().extend({
+    message: _v.string(),
+  })
+);
+
+export const getJobBatchStatusCountsSchema = defineSchema((v) =>
+  v.object({
+    submitted: v.number().int().nonnegative(),
+    working: v.number().int().nonnegative(),
+    completed: v.number().int().nonnegative(),
+    failed: v.number().int().nonnegative(),
+    canceled: v.number().int().nonnegative(),
+  })
+);
+
+export const getJobBatchResultSchema = defineSchema((v) =>
+  v
+    .discriminatedUnion("kind", [
+      v.object({
+        kind: v.literal("knowledge_ingest"),
+        total_count: v.number().int().nonnegative(),
+        completed_count: v.number().int().nonnegative(),
+        skipped_count: v.number().int().nonnegative(),
+        failed_count: v.number().int().nonnegative(),
+        processing: v.array(getKnowledgeIngestBatchSourceSchema()),
+        completed: v.array(getKnowledgeIngestBatchSourceSchema()),
+        skipped: v.array(getKnowledgeIngestBatchSourceWithMessageSchema()),
+        failed: v.array(getKnowledgeIngestBatchSourceWithMessageSchema()),
+        remaining: v.array(getKnowledgeIngestBatchSourceSchema()),
+        remaining_label: v.enum(["Remaining Files", "Not Ingested Files"] as const),
+      }),
+    ])
+    .nullable()
+);
+
+export const getJobBatchSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().uuid(),
+    project_id: v.string().uuid(),
+    target: v.string().nullable(),
+    job_count: v.number().int().nonnegative(),
+    status_counts: getJobBatchStatusCountsSchema(),
+    created_at: v.string(),
+    updated_at: v.string(),
+    result: getJobBatchResultSchema(),
+  })
+);
+
+export const getJobTargetDefinitionSchema = defineSchema((v) =>
+  v.object({
+    target: v.string(),
+    family: v.string(),
+    description: v.string(),
+    input_schema: jsonObjectSchema(v),
+    output_schema: jsonObjectSchema(v).nullable(),
+  })
+);
+
+export const getJobTargetDefinitionsResponseSchema = defineSchema((v) =>
+  v.object({
+    reserved_families: v.array(getReservedJobTargetFamilySchema()),
+    data: v.array(getJobTargetDefinitionSchema()),
+  })
+);
+
+export const getCronJobSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().uuid(),
+    project_id: v.string().uuid(),
+    environment_id: v.string().uuid().nullable(),
+    branch_id: v.string().nullable().optional(),
+    name: v.string(),
+    status: getCronJobStatusSchema(),
+    target: v.string(),
+    schedule: v.string(),
+    timezone: v.string(),
+    config: jsonObjectSchema(v),
+    timeout_seconds: v.number(),
+    backoff_limit: v.number(),
+    concurrency_policy: v.string(),
+    last_scheduled_at: v.string().nullable(),
+    last_successful_at: v.string().nullable(),
+    created_by: v.string().uuid().nullable(),
+    created_at: v.string(),
+    updated_at: v.string(),
+  })
+);
+
+export const getPaginatedCronJobsResponseSchema = defineSchema((v) =>
+  v.object({
+    data: v.array(getCronJobSchema()),
+    page_info: getPageInfoSchema(),
+  })
+);
+
+// Backward-compat aliases
+export const JobStatusSchema = getJobStatusSchema();
+export const CronJobStatusSchema = getCronJobStatusSchema();
+export const JobKindSchema = getJobKindSchema();
+export const ReservedJobTargetFamilySchema = getReservedJobTargetFamilySchema();
+export const PageInfoSchema = getPageInfoSchema();
+export const KnowledgeIngestFileResultSchema = getKnowledgeIngestFileResultSchema();
+export const KnowledgeIngestSkippedFileResultSchema = getKnowledgeIngestSkippedFileResultSchema();
+export const KnowledgeIngestFailedFileResultSchema = getKnowledgeIngestFailedFileResultSchema();
+export const KnowledgeIngestJobResultMetadataSchema = getKnowledgeIngestJobResultMetadataSchema();
+export const KnowledgeIngestJobResultCountsSchema = getKnowledgeIngestJobResultCountsSchema();
+export const KnowledgeIngestJobResultSchema = getKnowledgeIngestJobResultSchema();
+export const JobResultSchema = getJobResultSchema();
+export const JobResultSummarySchema = getJobResultSummarySchema();
+export const JobSchema = getJobSchema();
+export const JobListItemSchema = getJobListItemSchema();
+export const PaginatedJobsResponseSchema = getPaginatedJobsResponseSchema();
+export const JobEventSchema = getJobEventSchema();
+export const JobEventsResponseSchema = getJobEventsResponseSchema();
+export const JobLogsResponseSchema = getJobLogsResponseSchema();
+export const KnowledgeIngestBatchSourceSchema = getKnowledgeIngestBatchSourceSchema();
+export const KnowledgeIngestBatchSourceWithMessageSchema =
+  getKnowledgeIngestBatchSourceWithMessageSchema();
+export const JobBatchStatusCountsSchema = getJobBatchStatusCountsSchema();
+export const JobBatchResultSchema = getJobBatchResultSchema();
+export const JobBatchSchema = getJobBatchSchema();
+export const JobTargetDefinitionSchema = getJobTargetDefinitionSchema();
+export const JobTargetDefinitionsResponseSchema = getJobTargetDefinitionsResponseSchema();
+export const CronJobSchema = getCronJobSchema();
+export const PaginatedCronJobsResponseSchema = getPaginatedCronJobsResponseSchema();
+
+// Inferred types
+export type JobStatus = InferSchema<ReturnType<typeof getJobStatusSchema>>;
+export type CronJobStatus = InferSchema<ReturnType<typeof getCronJobStatusSchema>>;
+export type JobKind = InferSchema<ReturnType<typeof getJobKindSchema>>;
+export type ReservedJobTargetFamily = InferSchema<
+  ReturnType<typeof getReservedJobTargetFamilySchema>
+>;
+
+export type KnowledgeIngestFileResult = InferSchema<
+  ReturnType<typeof getKnowledgeIngestFileResultSchema>
 >;
-export type KnowledgeIngestFailedFileResult = z.infer<typeof KnowledgeIngestFailedFileResultSchema>;
-export type KnowledgeIngestJobResultMetadata = z.infer<
-  typeof KnowledgeIngestJobResultMetadataSchema
+export type KnowledgeIngestSkippedFileResult = InferSchema<
+  ReturnType<typeof getKnowledgeIngestSkippedFileResultSchema>
 >;
-export type KnowledgeIngestJobResultCounts = z.infer<typeof KnowledgeIngestJobResultCountsSchema>;
-export type KnowledgeIngestJobResult = z.infer<typeof KnowledgeIngestJobResultSchema>;
-export type JobResult = z.infer<typeof JobResultSchema>;
-export type JobResultSummary = z.infer<typeof JobResultSummarySchema>;
-export type Job = z.infer<typeof JobSchema>;
-export type JobListItem = z.infer<typeof JobListItemSchema>;
-export type PaginatedJobsResponse = z.infer<typeof PaginatedJobsResponseSchema>;
-export type JobEvent = z.infer<typeof JobEventSchema>;
-export type JobEventsResponse = z.infer<typeof JobEventsResponseSchema>;
-export type JobLogsResponse = z.infer<typeof JobLogsResponseSchema>;
-
-export type KnowledgeIngestBatchSource = z.infer<typeof KnowledgeIngestBatchSourceSchema>;
-export type KnowledgeIngestBatchSourceWithMessage = z.infer<
-  typeof KnowledgeIngestBatchSourceWithMessageSchema
+export type KnowledgeIngestFailedFileResult = InferSchema<
+  ReturnType<typeof getKnowledgeIngestFailedFileResultSchema>
 >;
-export type JobBatchStatusCounts = z.infer<typeof JobBatchStatusCountsSchema>;
-export type JobBatchResult = z.infer<typeof JobBatchResultSchema>;
-export type JobBatch = z.infer<typeof JobBatchSchema>;
+export type KnowledgeIngestJobResultMetadata = InferSchema<
+  ReturnType<typeof getKnowledgeIngestJobResultMetadataSchema>
+>;
+export type KnowledgeIngestJobResultCounts = InferSchema<
+  ReturnType<typeof getKnowledgeIngestJobResultCountsSchema>
+>;
+export type KnowledgeIngestJobResult = InferSchema<
+  ReturnType<typeof getKnowledgeIngestJobResultSchema>
+>;
+export type JobResult = InferSchema<ReturnType<typeof getJobResultSchema>>;
+export type JobResultSummary = InferSchema<ReturnType<typeof getJobResultSummarySchema>>;
+export type Job = InferSchema<ReturnType<typeof getJobSchema>>;
+export type JobListItem = InferSchema<ReturnType<typeof getJobListItemSchema>>;
+export type PaginatedJobsResponse = InferSchema<ReturnType<typeof getPaginatedJobsResponseSchema>>;
+export type JobEvent = InferSchema<ReturnType<typeof getJobEventSchema>>;
+export type JobEventsResponse = InferSchema<ReturnType<typeof getJobEventsResponseSchema>>;
+export type JobLogsResponse = InferSchema<ReturnType<typeof getJobLogsResponseSchema>>;
+
+export type KnowledgeIngestBatchSource = InferSchema<
+  ReturnType<typeof getKnowledgeIngestBatchSourceSchema>
+>;
+export type KnowledgeIngestBatchSourceWithMessage = InferSchema<
+  ReturnType<typeof getKnowledgeIngestBatchSourceWithMessageSchema>
+>;
+export type JobBatchStatusCounts = InferSchema<ReturnType<typeof getJobBatchStatusCountsSchema>>;
+export type JobBatchResult = InferSchema<ReturnType<typeof getJobBatchResultSchema>>;
+export type JobBatch = InferSchema<ReturnType<typeof getJobBatchSchema>>;
 
-export type JobTargetDefinition = z.infer<typeof JobTargetDefinitionSchema>;
-export type JobTargetDefinitionsResponse = z.infer<typeof JobTargetDefinitionsResponseSchema>;
+export type JobTargetDefinition = InferSchema<ReturnType<typeof getJobTargetDefinitionSchema>>;
+export type JobTargetDefinitionsResponse = InferSchema<
+  ReturnType<typeof getJobTargetDefinitionsResponseSchema>
+>;
 
-export type CronJob = z.infer<typeof CronJobSchema>;
-export type PaginatedCronJobsResponse = z.infer<typeof PaginatedCronJobsResponseSchema>;
+export type CronJob = InferSchema<ReturnType<typeof getCronJobSchema>>;
+export type PaginatedCronJobsResponse = InferSchema<
+  ReturnType<typeof getPaginatedCronJobsResponseSchema>
+>;