@read-frog/api-contract 0.12.6 → 0.15.0

package/src/schemas/srs.ts

@@ -1,3 +1,4 @@
+import { paginationShape } from "./pagination";
 import {
   activeScheduleStatusSchema,
   cardStateSchema,
@@ -7,82 +8,84 @@ import {
   schedulingParamsSchema,
   SRS_REVIEW_DURATION_MS_MAX,
   srsStepSchema,
-} from "@read-frog/definitions"
-import { z } from "zod"
-import { cardSchema } from "./card"
-import { timezoneSchema } from "./timezone"
+} from "@read-frog/definitions";
+import { z } from "zod";
+import { cardSchema } from "./card";
+import { timezoneSchema } from "./timezone";
 
-export {
-  reviewRatingSchema,
-  schedulingParamsSchema,
-  SRS_REVIEW_DURATION_MS_MAX,
-}
-export { timezoneSchema } from "./timezone"
-export type { Timezone } from "./timezone"
-export type { ReviewRating, SchedulingParams } from "@read-frog/definitions"
+export { reviewRatingSchema, schedulingParamsSchema, SRS_REVIEW_DURATION_MS_MAX };
+export { timezoneSchema } from "./timezone";
+export type { Timezone } from "./timezone";
+export type { ReviewRating, SchedulingParams } from "@read-frog/definitions";
 
-export const stepSchema = srsStepSchema
-export type Step = z.infer<typeof stepSchema>
+export const stepSchema = srsStepSchema;
+export type Step = z.infer<typeof stepSchema>;
 
-export const SRS_REVIEW_CLIENT_ID_NAMESPACE = "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
-const srsReviewClientIdNamePrefix = "readfrog:srs-review"
-const nullLastReviewTimeSentinel = "null"
+export const SRS_REVIEW_CLIENT_ID_NAMESPACE = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+const srsReviewClientIdNamePrefix = "readfrog:srs-review";
+const nullLastReviewTimeSentinel = "null";
 
 export interface SrsReviewClientIdCard {
-  id: string
-  lastReviewTime: Date | string | null
+  id: string;
+  lastReviewTime: Date | string | null;
 }
 
 export async function createSrsReviewClientId(card: SrsReviewClientIdCard) {
   return uuidV5(
     `${srsReviewClientIdNamePrefix}:${card.id}:${formatLastReviewTime(card.lastReviewTime)}`,
     SRS_REVIEW_CLIENT_ID_NAMESPACE,
-  )
+  );
 }
 
-export const srsReviewInputSchema = z.object({
-  cardId: z.uuid(),
-  id: z.uuid().optional(),
-  rating: reviewRatingSchema,
-  durationMs: z.number().int().min(0).max(SRS_REVIEW_DURATION_MS_MAX),
-  timezone: timezoneSchema,
-}).strict()
-export type SrsReviewInput = z.infer<typeof srsReviewInputSchema>
-
-export const srsRollbackReviewInputSchema = z.object({
-  cardId: z.uuid(),
-}).strict()
-export type SrsRollbackReviewInput = z.infer<typeof srsRollbackReviewInputSchema>
+export const srsReviewInputSchema = z
+  .object({
+    cardId: z.uuid(),
+    id: z.uuid().optional(),
+    rating: reviewRatingSchema,
+    durationMs: z.number().int().min(0).max(SRS_REVIEW_DURATION_MS_MAX),
+    timezone: timezoneSchema,
+  })
+  .strict();
+export type SrsReviewInput = z.infer<typeof srsReviewInputSchema>;
+
+export const srsRollbackReviewInputSchema = z
+  .object({
+    expectedReviewId: z.uuid().optional(),
+    cardId: z.uuid(),
+  })
+  .strict();
+export type SrsRollbackReviewInput = z.infer<typeof srsRollbackReviewInputSchema>;
 
 export const srsScheduleStatusStatsSchema = z.record(
   activeScheduleStatusSchema,
   z.number().int().min(0),
-)
-export type SrsScheduleStatusStats = z.infer<typeof srsScheduleStatusStatsSchema>
-
-export const srsScheduleStatusStatsInputSchema = z.object({
-  notebaseIds: z.array(z.uuid()).optional(),
-  timezone: timezoneSchema,
-}).strict()
-export type SrsScheduleStatusStatsInput = z.infer<typeof srsScheduleStatusStatsInputSchema>
-
-export const srsScheduleStatusStatsOutputSchema = z.record(
-  z.uuid(),
-  srsScheduleStatusStatsSchema,
-)
-export type SrsScheduleStatusStatsOutput = z.infer<typeof srsScheduleStatusStatsOutputSchema>
-
-export const srsManualCardStatusInputSchema = z.object({
-  cardId: z.uuid(),
-  enabled: z.boolean(),
-}).strict()
-export type SrsManualCardStatusInput = z.infer<typeof srsManualCardStatusInputSchema>
-
-export const srsSetCardBuriedInputSchema = srsManualCardStatusInputSchema
-export type SrsSetCardBuriedInput = SrsManualCardStatusInput
-
-export const srsSetCardSuspendedInputSchema = srsManualCardStatusInputSchema
-export type SrsSetCardSuspendedInput = SrsManualCardStatusInput
+);
+export type SrsScheduleStatusStats = z.infer<typeof srsScheduleStatusStatsSchema>;
+
+export const srsScheduleStatusStatsInputSchema = z
+  .object({
+    notebaseIds: z.array(z.uuid()).optional(),
+    timezone: timezoneSchema,
+  })
+  .strict();
+export type SrsScheduleStatusStatsInput = z.infer<typeof srsScheduleStatusStatsInputSchema>;
+
+export const srsScheduleStatusStatsOutputSchema = z.record(z.uuid(), srsScheduleStatusStatsSchema);
+export type SrsScheduleStatusStatsOutput = z.infer<typeof srsScheduleStatusStatsOutputSchema>;
+
+export const srsManualCardStatusInputSchema = z
+  .object({
+    cardId: z.uuid(),
+    enabled: z.boolean(),
+  })
+  .strict();
+export type SrsManualCardStatusInput = z.infer<typeof srsManualCardStatusInputSchema>;
+
+export const srsSetCardBuriedInputSchema = srsManualCardStatusInputSchema;
+export type SrsSetCardBuriedInput = SrsManualCardStatusInput;
+
+export const srsSetCardSuspendedInputSchema = srsManualCardStatusInputSchema;
+export type SrsSetCardSuspendedInput = SrsManualCardStatusInput;
 
 export const srsRevlogSchema = z.object({
   id: z.uuid(),
@@ -97,23 +100,30 @@ export const srsRevlogSchema = z.object({
   durationMs: z.number().int(),
   fsrsReviewLogSnapshot: fsrsReviewLogSnapshotSchema,
   createdAt: z.coerce.date(),
-})
-export type SrsRevlog = z.infer<typeof srsRevlogSchema>
+});
+export type SrsRevlog = z.infer<typeof srsRevlogSchema>;
 
 export const srsRevlogWithoutSnapshotSchema = srsRevlogSchema.omit({
   fsrsReviewLogSnapshot: true,
-})
-export type SrsRevlogWithoutSnapshot = z.infer<typeof srsRevlogWithoutSnapshotSchema>
-
-export const srsListCardRevlogsInputSchema = z.object({
-  cardId: z.uuid(),
-}).strict()
-export type SrsListCardRevlogsInput = z.infer<typeof srsListCardRevlogsInputSchema>
-
-export const srsListCardRevlogsOutputSchema = z.object({
-  items: z.array(srsRevlogWithoutSnapshotSchema),
-}).strict()
-export type SrsListCardRevlogsOutput = z.infer<typeof srsListCardRevlogsOutputSchema>
+});
+export type SrsRevlogWithoutSnapshot = z.infer<typeof srsRevlogWithoutSnapshotSchema>;
+
+export const srsListCardRevlogsInputSchema = z
+  .object({
+    ...paginationShape,
+    notebaseId: z.uuid().optional(),
+    cardId: z.uuid().optional(),
+  })
+  .strict();
+export type SrsListCardRevlogsInput = z.infer<typeof srsListCardRevlogsInputSchema>;
+
+export const srsListCardRevlogsOutputSchema = z
+  .object({
+    items: z.array(srsRevlogWithoutSnapshotSchema),
+    hasMore: z.boolean(),
+  })
+  .strict();
+export type SrsListCardRevlogsOutput = z.infer<typeof srsListCardRevlogsOutputSchema>;
 
 export const srsReviewOutputSchema = z.object({
   card: cardSchema,
@@ -121,71 +131,107 @@ export const srsReviewOutputSchema = z.object({
   txid: z.number(),
   // False when an idempotent replay returned an existing revlog instead of creating one.
   created: z.boolean(),
-})
-export type SrsReviewOutput = z.infer<typeof srsReviewOutputSchema>
+});
+export type SrsReviewOutput = z.infer<typeof srsReviewOutputSchema>;
 
 export const srsRollbackReviewOutputSchema = z.object({
   card: cardSchema,
   rolledBackRevlogId: z.uuid(),
   txid: z.number(),
-})
-export type SrsRollbackReviewOutput = z.infer<typeof srsRollbackReviewOutputSchema>
+});
+export type SrsRollbackReviewOutput = z.infer<typeof srsRollbackReviewOutputSchema>;
 
 export const srsTxidOutputSchema = z.object({
   txid: z.number(),
-})
-export type SrsTxidOutput = z.infer<typeof srsTxidOutputSchema>
-
-export const srsSetCardBuriedOutputSchema = srsTxidOutputSchema
-export type SrsSetCardBuriedOutput = SrsTxidOutput
-
-export const srsSetCardSuspendedOutputSchema = srsTxidOutputSchema
-export type SrsSetCardSuspendedOutput = SrsTxidOutput
+});
+export type SrsTxidOutput = z.infer<typeof srsTxidOutputSchema>;
+
+export const srsSetCardBuriedOutputSchema = srsTxidOutputSchema;
+export type SrsSetCardBuriedOutput = SrsTxidOutput;
+
+export const srsSetCardSuspendedOutputSchema = srsTxidOutputSchema;
+export type SrsSetCardSuspendedOutput = SrsTxidOutput;
+
+export const srsListUnreadOptimizerResultsInputSchema = z.object({}).strict();
+
+export const srsOptimizerUnreadResultSchema = z
+  .object({
+    runId: z.uuid(),
+    notebaseName: z.string().min(1),
+    revlogCount: z.number().int().positive(),
+    improvement: z.number().nonnegative().nullable(),
+  })
+  .strict();
+export type SrsOptimizerUnreadResult = z.infer<typeof srsOptimizerUnreadResultSchema>;
+
+export const srsListUnreadOptimizerResultsOutputSchema = z.array(srsOptimizerUnreadResultSchema);
+export type SrsListUnreadOptimizerResultsOutput = z.infer<
+  typeof srsListUnreadOptimizerResultsOutputSchema
+>;
+
+export const srsAcknowledgeOptimizerResultsInputSchema = z
+  .object({
+    runIds: z.array(z.uuid()).min(1),
+  })
+  .strict();
+export type SrsAcknowledgeOptimizerResultsInput = z.infer<
+  typeof srsAcknowledgeOptimizerResultsInputSchema
+>;
+
+export const srsAcknowledgeOptimizerResultsOutputSchema = z
+  .object({
+    acknowledgedCount: z.number().int().nonnegative(),
+  })
+  .strict();
+export type SrsAcknowledgeOptimizerResultsOutput = z.infer<
+  typeof srsAcknowledgeOptimizerResultsOutputSchema
+>;
 
 function formatLastReviewTime(lastReviewTime: Date | string | null) {
-  return lastReviewTime ? new Date(lastReviewTime).toISOString() : nullLastReviewTimeSentinel
+  return lastReviewTime ? new Date(lastReviewTime).toISOString() : nullLastReviewTimeSentinel;
 }
 
 async function uuidV5(name: string, namespace: string) {
-  const namespaceBytes = uuidToBytes(namespace)
-  const nameBytes = new TextEncoder().encode(name)
-  const input = new Uint8Array(namespaceBytes.length + nameBytes.length)
-  input.set(namespaceBytes)
-  input.set(nameBytes, namespaceBytes.length)
-
-  const hash = new Uint8Array(await crypto.subtle.digest("SHA-1", input))
-  const bytes = hash.slice(0, 16)
-  const versionByte = bytes[6]
-  const variantByte = bytes[8]
+  const namespaceBytes = uuidToBytes(namespace);
+  const nameBytes = new TextEncoder().encode(name);
+  const input = new Uint8Array(namespaceBytes.length + nameBytes.length);
+  input.set(namespaceBytes);
+  input.set(nameBytes, namespaceBytes.length);
+
+  const hash = new Uint8Array(await crypto.subtle.digest("SHA-1", input));
+  const bytes = hash.slice(0, 16);
+  const versionByte = bytes[6];
+  const variantByte = bytes[8];
   if (versionByte === undefined || variantByte === undefined) {
-    throw new Error("SHA-1 digest was too short")
+    throw new Error("SHA-1 digest was too short");
   }
-  bytes[6] = (versionByte & 0x0F) | 0x50
-  bytes[8] = (variantByte & 0x3F) | 0x80
+  bytes[6] = (versionByte & 0x0f) | 0x50;
+  bytes[8] = (variantByte & 0x3f) | 0x80;
 
-  return bytesToUuid(bytes)
+  return bytesToUuid(bytes);
 }
 
 function uuidToBytes(uuid: string) {
-  const hex = uuid.replaceAll("-", "").toLowerCase()
+  const hex = uuid.replaceAll("-", "").toLowerCase();
   /* v8 ignore next 3 -- SRS_REVIEW_CLIENT_ID_NAMESPACE is a fixed valid UUID. */
   if (!/^[0-9a-f]{32}$/.test(hex)) {
-    throw new Error("Invalid UUID namespace")
+    throw new Error("Invalid UUID namespace");
   }
 
   return new Uint8Array(
     Array.from({ length: 16 }, (_, index) =>
-      Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16)),
-  )
+      Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16),
+    ),
+  );
 }
 
 function bytesToUuid(bytes: Uint8Array) {
-  const hex = Array.from(bytes, byte => byte.toString(16).padStart(2, "0"))
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
   return [
     hex.slice(0, 4).join(""),
     hex.slice(4, 6).join(""),
     hex.slice(6, 8).join(""),
     hex.slice(8, 10).join(""),
     hex.slice(10, 16).join(""),
-  ].join("-")
+  ].join("-");
 }

package/src/schemas/stats.ts

@@ -1,25 +1,31 @@
-import { z } from "zod"
-import { notebaseActivityStatsOutputSchema } from "./notebase-stats"
-import { srsActivityStatsOutputSchema } from "./srs-stats"
-import { timezoneSchema } from "./timezone"
+import { z } from "zod";
+import { notebaseActivityStatsOutputSchema } from "./notebase-stats";
+import { srsActivityStatsOutputSchema } from "./srs-stats";
+import { timezoneSchema } from "./timezone";
 
-const statsNotebaseIdsSchema = z.array(z.uuid())
+const statsNotebaseIdsSchema = z
+  .array(z.uuid())
   .min(1)
-  .transform(ids => Array.from(new Set(ids)))
+  .transform((ids) => Array.from(new Set(ids)));
 
-export const statsInputSchema = z.object({
-  notebaseIds: statsNotebaseIdsSchema.optional(),
-  from: z.iso.date().optional(),
-  to: z.iso.date(),
-  timezone: timezoneSchema,
-}).strict().refine(input => !input.from || input.from <= input.to, {
-  message: "from must be before or equal to to",
-  path: ["from"],
-})
-export type StatsInput = z.infer<typeof statsInputSchema>
+export const statsInputSchema = z
+  .object({
+    notebaseIds: statsNotebaseIdsSchema.optional(),
+    from: z.iso.date().optional(),
+    to: z.iso.date(),
+    timezone: timezoneSchema,
+  })
+  .strict()
+  .refine((input) => !input.from || input.from <= input.to, {
+    message: "from must be before or equal to to",
+    path: ["from"],
+  });
+export type StatsInput = z.infer<typeof statsInputSchema>;
 
-export const activityStatsOutputSchema = z.object({
-  srs: srsActivityStatsOutputSchema,
-  notebase: notebaseActivityStatsOutputSchema,
-}).strict()
-export type ActivityStatsOutput = z.infer<typeof activityStatsOutputSchema>
+export const activityStatsOutputSchema = z
+  .object({
+    srs: srsActivityStatsOutputSchema,
+    notebase: notebaseActivityStatsOutputSchema,
+  })
+  .strict();
+export type ActivityStatsOutput = z.infer<typeof activityStatsOutputSchema>;

package/src/schemas/timezone.ts

@@ -1,23 +1,26 @@
-import { z } from "zod"
+import { z } from "zod";
 
 // @ref https://zenn.dev/herp_inc/articles/js-intl-date-time-format-performance
-const localeTimeZoneFormatter = new Map<string, Intl.DateTimeFormat>()
+const localeTimeZoneFormatter = new Map<string, Intl.DateTimeFormat>();
 function createTimezoneFormatter(timezone: string): Intl.DateTimeFormat {
-  let formatter = localeTimeZoneFormatter.get(timezone)
+  let formatter = localeTimeZoneFormatter.get(timezone);
   if (!formatter) {
-    formatter = new Intl.DateTimeFormat("en-US", { timeZone: timezone })
-    localeTimeZoneFormatter.set(timezone, formatter)
+    formatter = new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+    localeTimeZoneFormatter.set(timezone, formatter);
   }
-  return formatter
+  return formatter;
 }
 
-export const timezoneSchema = z.string().trim().min(1).refine((timezone) => {
-  try {
-    createTimezoneFormatter(timezone).format(new Date())
-    return true
-  }
-  catch {
-    return false
-  }
-}, "Invalid timezone")
-export type Timezone = z.infer<typeof timezoneSchema>
+export const timezoneSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .refine((timezone) => {
+    try {
+      createTimezoneFormatter(timezone).format(new Date());
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Invalid timezone");
+export type Timezone = z.infer<typeof timezoneSchema>;

package/src/schemas/user.ts

@@ -1,23 +1,31 @@
-import { z } from "zod"
-import { timezoneSchema } from "./timezone"
+import { z } from "zod";
+import { timezoneSchema } from "./timezone";
 
-export const userEnsureTimezoneInputSchema = z.object({
-  timezone: timezoneSchema,
-}).strict()
-export type UserEnsureTimezoneInput = z.infer<typeof userEnsureTimezoneInputSchema>
+export const userEnsureTimezoneInputSchema = z
+  .object({
+    timezone: timezoneSchema,
+  })
+  .strict();
+export type UserEnsureTimezoneInput = z.infer<typeof userEnsureTimezoneInputSchema>;
 
-export const userEnsureTimezoneOutputSchema = z.object({
-  timezone: timezoneSchema,
-  updated: z.boolean(),
-}).strict()
-export type UserEnsureTimezoneOutput = z.infer<typeof userEnsureTimezoneOutputSchema>
+export const userEnsureTimezoneOutputSchema = z
+  .object({
+    timezone: timezoneSchema,
+    updated: z.boolean(),
+  })
+  .strict();
+export type UserEnsureTimezoneOutput = z.infer<typeof userEnsureTimezoneOutputSchema>;
 
-export const userUpdateTimezoneInputSchema = z.object({
-  timezone: timezoneSchema,
-}).strict()
-export type UserUpdateTimezoneInput = z.infer<typeof userUpdateTimezoneInputSchema>
+export const userUpdateTimezoneInputSchema = z
+  .object({
+    timezone: timezoneSchema,
+  })
+  .strict();
+export type UserUpdateTimezoneInput = z.infer<typeof userUpdateTimezoneInputSchema>;
 
-export const userUpdateTimezoneOutputSchema = z.object({
-  timezone: timezoneSchema,
-}).strict()
-export type UserUpdateTimezoneOutput = z.infer<typeof userUpdateTimezoneOutputSchema>
+export const userUpdateTimezoneOutputSchema = z
+  .object({
+    timezone: timezoneSchema,
+  })
+  .strict();
+export type UserUpdateTimezoneOutput = z.infer<typeof userUpdateTimezoneOutputSchema>;

package/src/schemas/video-transcript.ts

@@ -1,13 +1,9 @@
-import { getVideoIdFromUrl, transcriptSegmentSchema } from "@read-frog/definitions"
-import { z } from "zod"
+import { getVideoIdFromUrl, transcriptSegmentSchema } from "@read-frog/definitions";
+import { z } from "zod";
+import { billingPlanSchema } from "./billing";
 
-export const videoTranscriptStatusSchema = z.enum([
-  "pending",
-  "processing",
-  "completed",
-  "failed",
-])
-export type VideoTranscriptStatus = z.infer<typeof videoTranscriptStatusSchema>
+export const videoTranscriptStatusSchema = z.enum(["pending", "processing", "completed", "failed"]);
+export type VideoTranscriptStatus = z.infer<typeof videoTranscriptStatusSchema>;
 
 // The transcript "job" resource: status + metadata, without the (heavy) segments payload.
 export const videoTranscriptResourceSchema = z.object({
@@ -22,31 +18,64 @@ export const videoTranscriptResourceSchema = z.object({
   error: z.string().nullable(),
   createdAt: z.date(),
   updatedAt: z.date(),
-})
-export type VideoTranscriptResource = z.infer<typeof videoTranscriptResourceSchema>
+});
+export type VideoTranscriptResource = z.infer<typeof videoTranscriptResourceSchema>;
 
 // The subtitles sub-resource: the segments + model-detected language, only available once completed.
 export const videoTranscriptSubtitlesSchema = z.object({
   id: z.string(),
   detectedLanguage: z.string().nullable(),
   segments: z.array(transcriptSegmentSchema),
-})
-export type VideoTranscriptSubtitles = z.infer<typeof videoTranscriptSubtitlesSchema>
+});
+export type VideoTranscriptSubtitles = z.infer<typeof videoTranscriptSubtitlesSchema>;
 
-export const videoTranscriptCreateInputSchema = z.object({
-  url: z.url().refine(url => getVideoIdFromUrl(url) !== null, { message: "url must be a supported video URL" }),
-}).strict()
-export type VideoTranscriptCreateInput = z.infer<typeof videoTranscriptCreateInputSchema>
+export const videoTranscriptCreateInputSchema = z
+  .object({
+    url: z.url().refine((url) => getVideoIdFromUrl(url) !== null, {
+      message: "url must be a supported video URL",
+    }),
+    // The player's own duration, read from the media element. REQUIRED, and an
+    // untrusted UX hint only: admission uses it to reject an over-quota request
+    // instantly, but every reservation and charge is made against the
+    // server-measured duration in the worker — lying here changes nothing about
+    // what gets billed.
+    durationSec: z.number().int().positive(),
+  })
+  .strict();
+export type VideoTranscriptCreateInput = z.infer<typeof videoTranscriptCreateInputSchema>;
 
-export const videoTranscriptGetInputSchema = z.object({
-  id: z.uuid(),
-}).strict()
-export type VideoTranscriptGetInput = z.infer<typeof videoTranscriptGetInputSchema>
+export const videoTranscriptGetInputSchema = z
+  .object({
+    id: z.uuid(),
+  })
+  .strict();
+export type VideoTranscriptGetInput = z.infer<typeof videoTranscriptGetInputSchema>;
 
-// The caller's monthly transcription usage against the beta quota.
+// One quota pool as shown to the user. `resetAt` is null for a one-time grant
+// (it never resets); `expiresAt` is null for a monthly pool (its end is the
+// reset). Minutes are display units: `usedMinutes` rounds up and
+// `limitMinutes` rounds down, so the UI can never show headroom that
+// admission (which compares raw seconds) would deny.
+export const videoTranscriptUsagePoolSchema = z.object({
+  id: z.string(),
+  usedMinutes: z.number().int(),
+  limitMinutes: z.number().int(),
+  remainingMinutes: z.number().int(),
+  resetAt: z.iso.datetime().nullable(),
+  expiresAt: z.iso.datetime().nullable(),
+});
+export type VideoTranscriptUsagePool = z.infer<typeof videoTranscriptUsagePoolSchema>;
+
+// The caller's transcription quota usage. Totals aggregate across pools;
+// `remainingMinutes` nets out in-flight reservations (committed), while each
+// pool's `usedMinutes` shows settled spend only, so a progress bar cannot run
+// forward and then backwards when a job is released. Deliberately a non-strict
+// object: old clients strip the keys they don't know.
 export const videoTranscriptUsageSchema = z.object({
   usedMinutes: z.number().int(),
   limitMinutes: z.number().int(),
   remainingMinutes: z.number().int(),
-})
-export type VideoTranscriptUsage = z.infer<typeof videoTranscriptUsageSchema>
+  plan: billingPlanSchema,
+  pools: z.array(videoTranscriptUsagePoolSchema),
+});
+export type VideoTranscriptUsage = z.infer<typeof videoTranscriptUsageSchema>;