@strong-together/shared 1.1.0 → 2.0.0

package/dist/index.js

@@ -1,469 +1,1913 @@
-"use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  addAerobicsRequest: () => addAerobicsRequest,
-  addWorkoutRequest: () => addWorkoutRequest,
-  addWorkoutResponseSchema: () => addWorkoutResponseSchema,
-  adherenceExerciseStatsSchema: () => adherenceExerciseStatsSchema,
-  aerobicsDailyRecordSchema: () => aerobicsDailyRecordSchema,
-  aerobicsWeeklyRecordSchema: () => aerobicsWeeklyRecordSchema,
-  allUserMessageSchema: () => allUserMessageSchema,
-  appleOAuthRequest: () => appleOAuthRequest,
-  bootstrapRequest: () => bootstrapRequest,
-  bootstrapResponseSchema: () => bootstrapResponseSchema,
-  changeEmailAndVerifyRequest: () => changeEmailAndVerifyRequest,
-  checkUserVerifyRequest: () => checkUserVerifyRequest,
-  createUserRequest: () => createUserRequest,
-  createUserResponseSchema: () => createUserResponseSchema,
-  createUserUserSchema: () => createUserUserSchema,
-  deleteMessageRequest: () => deleteMessageRequest,
-  deleteMessageResponseSchema: () => deleteMessageResponseSchema,
-  deleteProfilePicRequest: () => deleteProfilePicRequest,
-  deletedMessageSchema: () => deletedMessageSchema,
-  exerciseInPlanSchema: () => exerciseInPlanSchema,
-  exerciseMetadataSchema: () => exerciseMetadataSchema,
-  exerciseTrackingAnalysisSchema: () => exerciseTrackingAnalysisSchema,
-  exerciseTrackingAndStatsSchema: () => exerciseTrackingAndStatsSchema,
-  exerciseTrackingPrMaxSchema: () => exerciseTrackingPrMaxSchema,
-  finishUserWorkoutResponseSchema: () => finishUserWorkoutResponseSchema,
-  finishWorkoutRequest: () => finishWorkoutRequest,
-  generateTicketRequest: () => generateTicketRequest,
-  generateTicketResponseSchema: () => generateTicketResponseSchema,
-  getAerobicsRequest: () => getAerobicsRequest,
-  getAllExercisesResponseSchema: () => getAllExercisesResponseSchema,
-  getAllMessagesRequest: () => getAllMessagesRequest,
-  getAllUserMessagesResponseSchema: () => getAllUserMessagesResponseSchema,
-  getAnalyticsResponseSchema: () => getAnalyticsResponseSchema,
-  getAuthenticatedUserByIdResponseSchema: () => getAuthenticatedUserByIdResponseSchema,
-  getExerciseTrackingRequest: () => getExerciseTrackingRequest,
-  getExerciseTrackingResponseSchema: () => getExerciseTrackingResponseSchema,
-  getPresignedUrlFromS3ResponseSchema: () => getPresignedUrlFromS3ResponseSchema,
-  getPresignedUrlS3Request: () => getPresignedUrlS3Request,
-  getWholeUserWorkoutPlanResponseSchema: () => getWholeUserWorkoutPlanResponseSchema,
-  getWholeWorkoutPlanRequest: () => getWholeWorkoutPlanRequest,
-  googleOAuthRequest: () => googleOAuthRequest,
-  loginRequest: () => loginRequest,
-  loginResponseSchema: () => loginResponseSchema,
-  logoutResponseSchema: () => logoutResponseSchema,
-  markMessageAsReadRequest: () => markMessageAsReadRequest,
-  markMessageAsReadResponseSchema: () => markMessageAsReadResponseSchema,
-  messageAsReadSchema: () => messageAsReadSchema,
-  oAuthLoginResponseSchema: () => oAuthLoginResponseSchema,
-  proceedLoginResponseSchema: () => proceedLoginResponseSchema,
-  refreshTokenResponseSchema: () => refreshTokenResponseSchema,
-  resetPasswordRequest: () => resetPasswordRequest,
-  resetPasswordResponseSchema: () => resetPasswordResponseSchema,
-  saveUserPushTokenRequest: () => saveUserPushTokenRequest,
-  sendChangePassEmailRequest: () => sendChangePassEmailRequest,
-  sendVerificationMailRequest: () => sendVerificationMailRequest,
-  setProfilePicAndUpdateDBResponseSchema: () => setProfilePicAndUpdateDBResponseSchema,
-  trackingByDateItemSchema: () => trackingByDateItemSchema,
-  trackingBySplitNameItemSchema: () => trackingBySplitNameItemSchema,
-  trackingMapItemSchema: () => trackingMapItemSchema,
-  updateAuthenticatedUserResponseSchema: () => updateAuthenticatedUserResponseSchema,
-  updateUserRequest: () => updateUserRequest,
-  userAerobicsResponseSchema: () => userAerobicsResponseSchema,
-  userDataResponseSchema: () => userDataResponseSchema,
-  userDataSchema: () => userDataSchema,
-  verifyAccountRequest: () => verifyAccountRequest,
-  weeklyDataSchema: () => weeklyDataSchema,
-  wholeUserWorkoutPlanSchema: () => wholeUserWorkoutPlanSchema,
-  workoutRmRecordSchema: () => workoutRmRecordSchema,
-  workoutSplitSchema: () => workoutSplitSchema,
-  workoutSplitsMapItemSchema: () => workoutSplitsMapItemSchema,
-  workoutSplitsMapSchema: () => workoutSplitsMapSchema
-});
-module.exports = __toCommonJS(index_exports);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/common/transport.schemas.ts
+import { z } from "zod/v4";
+var serializedDateSchema = z.string();
+var timezoneSchema = z.string();
+
+// src/database/database.schemas.ts
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+
+// ../../src/infrastructure/db/schema/drizzle/roles.ts
+import { pgRole } from "drizzle-orm/pg-core";
+var anonRole = pgRole("anon");
+var authenticatedRole = pgRole("authenticated");
+var guestRole = pgRole("guest");
+var serviceRole = pgRole("service_role");
+var appUserRole = pgRole("app_user");
+var appRuntimeUserRole = pgRole("app_runtime_user", {
+  createDb: false,
+  createRole: false,
+  inherit: false
+});
+
+// ../../src/infrastructure/db/schema/drizzle/schemas.ts
+import { pgSchema } from "drizzle-orm/pg-core";
+var authSchema = pgSchema("auth");
+var identitySchema = pgSchema("identity");
+var workoutSchema = pgSchema("workout");
+var trackingSchema = pgSchema("tracking");
+var remindersSchema = pgSchema("reminders");
+var analyticsSchema = pgSchema("analytics");
+var messagesSchema = pgSchema("messages");
+var authProviders = identitySchema.enum("Auth Providers", [
+  "apple",
+  "google",
+  "app"
+]);
+
+// ../../src/infrastructure/db/schema/drizzle/identity/user/table.ts
+import { relations as relations14, sql as drizzleSql24 } from "drizzle-orm";
+import { bigint as bigint11, boolean as boolean6, primaryKey as primaryKey14, text as text8, timestamp as timestamp10, uniqueIndex as uniqueIndex3, uuid as uuid11 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/messages/messages/table.ts
+import { relations, sql as drizzleSql2 } from "drizzle-orm";
+import { boolean, foreignKey, index, primaryKey, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/messages/messages/policies.ts
+import { sql as drizzleSql } from "drizzle-orm";
+import { pgPolicy } from "drizzle-orm/pg-core";
+var uid = drizzleSql`"identity"."current_user_id"()`;
+function messagePolicies(t) {
+  const participant = drizzleSql`${uid} = ${t.senderId} or ${uid} = ${t.receiverId}`;
+  return [
+    // Lets authenticated message participants read their sent or received messages.
+    pgPolicy("Enable read access for auth users on message", {
+      for: "select",
+      to: authenticatedRole,
+      using: participant
+    }),
+    // Lets authenticated users send as themselves or as the existing system sender.
+    pgPolicy("Enable insert for auth users on message", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: drizzleSql`${uid} = ${t.senderId} or ${t.senderId} = '8dedd0e0-8c25-4c84-a05b-4ae5f5c48f3a'::uuid`
+    }),
+    // Lets authenticated message participants update a message while remaining participants.
+    pgPolicy("Enable update for auth users on message", {
+      for: "update",
+      to: authenticatedRole,
+      using: participant,
+      withCheck: participant
+    }),
+    // Lets authenticated message participants delete their sent or received messages.
+    pgPolicy("Enable delete for auth users on message", {
+      for: "delete",
+      to: authenticatedRole,
+      using: participant
+    })
+  ];
+}
+__name(messagePolicies, "messagePolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/messages/messages/table.ts
+var uid2 = drizzleSql2`"identity"."current_user_id"()`;
+var message = messagesSchema.table("message", {
+  id: uuid("id").defaultRandom().notNull(),
+  senderId: uuid("sender_id").default(uid2).notNull(),
+  receiverId: uuid("receiver_id").default(uid2).notNull(),
+  subject: text("subject").default("Subject").notNull(),
+  msg: text("msg").default("Hello World").notNull(),
+  sentAt: timestamp("sent_at", {
+    withTimezone: true
+  }).default(drizzleSql2`(now() AT TIME ZONE 'utc')`).notNull(),
+  isRead: boolean("is_read").default(false).notNull()
+}, (t) => [
+  primaryKey({
+    name: "message_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  foreignKey({
+    name: "message_sender_id_fkey",
+    columns: [
+      t.senderId
+    ],
+    foreignColumns: [
+      user.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  foreignKey({
+    name: "message_receiver_id_fkey",
+    columns: [
+      t.receiverId
+    ],
+    foreignColumns: [
+      user.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  index("message_receiver_id_idx").on(t.receiverId),
+  ...messagePolicies(t)
+]);
+var messageRelations = relations(message, ({ one }) => ({
+  sender: one(user, {
+    fields: [
+      message.senderId
+    ],
+    references: [
+      user.id
+    ],
+    relationName: "messageSender"
+  }),
+  receiver: one(user, {
+    fields: [
+      message.receiverId
+    ],
+    references: [
+      user.id
+    ],
+    relationName: "messageReceiver"
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/reminders/user_reminder_setting/table.ts
+import { relations as relations2, sql as drizzleSql4 } from "drizzle-orm";
+import { boolean as boolean2, foreignKey as foreignKey2, integer, primaryKey as primaryKey2, text as text2, timestamp as timestamp2, uuid as uuid2 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/reminders/user_reminder_setting/policies.ts
+import { sql as drizzleSql3 } from "drizzle-orm";
+import { pgPolicy as pgPolicy2 } from "drizzle-orm/pg-core";
+var uid3 = drizzleSql3`"identity"."current_user_id"()`;
+function userReminderSettingPolicies(t) {
+  return [
+    // Lets authenticated users read only their own reminder settings.
+    pgPolicy2("auth can SELECT own reminder settings", {
+      for: "select",
+      to: authenticatedRole,
+      using: drizzleSql3`${uid3} = ${t.userId}`
+    }),
+    // Lets authenticated users insert reminder settings only for themselves.
+    pgPolicy2("auth can INSERT own reminder settings", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: drizzleSql3`${uid3} = ${t.userId}`
+    }),
+    // Lets authenticated users update their own reminder settings and preserves ownership.
+    pgPolicy2("auth can UPDATE own reminder settings", {
+      for: "update",
+      to: authenticatedRole,
+      using: drizzleSql3`${uid3} = ${t.userId}`,
+      withCheck: drizzleSql3`${uid3} = ${t.userId}`
+    }),
+    // Provides the original additional update policy for settings owned by the user.
+    pgPolicy2("Allow authenticated users to update their own reminder settings", {
+      for: "update",
+      to: authenticatedRole,
+      using: drizzleSql3`${uid3} = ${t.userId}`
+    })
+  ];
+}
+__name(userReminderSettingPolicies, "userReminderSettingPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/reminders/user_reminder_setting/table.ts
+var userReminderSetting = remindersSchema.table("user_reminder_setting", {
+  userId: uuid2("user_id").notNull(),
+  workoutRemindersEnabled: boolean2("workout_reminders_enabled").default(true).notNull(),
+  reminderOffsetMinutes: integer("reminder_offset_minutes").default(60).notNull(),
+  updatedAt: timestamp2("updated_at", {
+    withTimezone: true
+  }).default(drizzleSql4`timezone('UTC', now())`).notNull(),
+  timezone: text2("timezone").default("'UTC'::text")
+}, (t) => [
+  primaryKey2({
+    name: "user_reminder_setting_pkey",
+    columns: [
+      t.userId
+    ]
+  }),
+  foreignKey2({
+    name: "user_reminder_setting_user_id_fkey",
+    columns: [
+      t.userId
+    ],
+    foreignColumns: [
+      user.id
+    ]
+  }).onDelete("cascade"),
+  ...userReminderSettingPolicies(t)
+]);
+var userReminderSettingRelations = relations2(userReminderSetting, ({ one }) => ({
+  user: one(user, {
+    fields: [
+      userReminderSetting.userId
+    ],
+    references: [
+      user.id
+    ]
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/reminders/user_split_information/table.ts
+import { relations as relations11, sql as drizzleSql18 } from "drizzle-orm";
+import { bigint as bigint9, foreignKey as foreignKey10, index as index8, integer as integer4, numeric, primaryKey as primaryKey11, timestamp as timestamp7, unique as unique5, uuid as uuid8 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_split/table.ts
+import { relations as relations10, sql as drizzleSql17 } from "drizzle-orm";
+import { bigint as bigint8, boolean as boolean5, foreignKey as foreignKey9, index as index7, primaryKey as primaryKey10, text as text5, timestamp as timestamp6, unique as unique4 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/workout_summary/table.ts
+import { relations as relations8, sql as drizzleSql13 } from "drizzle-orm";
+import { bigint as bigint6, foreignKey as foreignKey7, index as index6, primaryKey as primaryKey8, timestamp as timestamp4, uuid as uuid6 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/exercise_tracking/table.ts
+import { relations as relations7, sql as drizzleSql11 } from "drizzle-orm";
+import { bigint as bigint5, foreignKey as foreignKey6, index as index5, primaryKey as primaryKey7, text as text4, uuid as uuid5 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/workout/exercises/table.ts
+import { relations as relations5 } from "drizzle-orm";
+import { bigint as bigint3, primaryKey as primaryKey5, text as text3, uniqueIndex } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/workout/exercisetoworkoutsplit/table.ts
+import { relations as relations4, sql as drizzleSql7 } from "drizzle-orm";
+import { bigint as bigint2, boolean as boolean3, foreignKey as foreignKey4, index as index3, primaryKey as primaryKey4, timestamp as timestamp3, unique as unique2 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_set/table.ts
+import { relations as relations3 } from "drizzle-orm";
+import { bigint, foreignKey as foreignKey3, index as index2, integer as integer2, primaryKey as primaryKey3, unique, uuid as uuid3 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_set/policies.ts
+import { sql as drizzleSql5 } from "drizzle-orm";
+import { pgPolicy as pgPolicy3 } from "drizzle-orm/pg-core";
+var currentUserId = drizzleSql5`"identity"."current_user_id"()`;
+function workoutSetPolicies(table) {
+  const ownsWorkoutSet = drizzleSql5`exists (
+    select 1
+    from "workout"."exercise_to_workout_split" ets
+    join "workout"."workout_split" ws on ws."id" = ets."workout_split_id"
+    join "workout"."workout_plan" wp on wp."id" = ws."workout_id"
+    where ets."id" = ${table.exerciseToSplitId}
+      and wp."user_id" = ${currentUserId}
+  )`;
+  return [
+    // Lets authenticated users read planned sets only from workout plans they own.
+    pgPolicy3("Enable read access for auth users on workout_set", {
+      for: "select",
+      to: authenticatedRole,
+      using: ownsWorkoutSet
+    }),
+    // Lets authenticated users add planned sets only to workout plans they own.
+    pgPolicy3("Enable insert for auth users on workout_set", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: ownsWorkoutSet
+    }),
+    // Lets authenticated users update planned sets only within workout plans they own.
+    pgPolicy3("Enable update for auth users on workout_set", {
+      for: "update",
+      to: authenticatedRole,
+      using: ownsWorkoutSet,
+      withCheck: ownsWorkoutSet
+    }),
+    // Lets authenticated users delete planned sets only from workout plans they own.
+    pgPolicy3("Enable delete for auth users on workout_set", {
+      for: "delete",
+      to: authenticatedRole,
+      using: ownsWorkoutSet
+    })
+  ];
+}
+__name(workoutSetPolicies, "workoutSetPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_set/table.ts
+var workoutSet = workoutSchema.table("workout_set", {
+  id: uuid3("id").defaultRandom().notNull(),
+  exerciseToSplitId: bigint("exercise_to_split_id", {
+    mode: "number"
+  }).notNull(),
+  orderIndex: integer2("order_index").notNull(),
+  reps: integer2("reps").notNull()
+}, (t) => [
+  primaryKey3({
+    name: "workout_set_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  unique("workout_set_exercise_order_unique").on(t.exerciseToSplitId, t.orderIndex),
+  foreignKey3({
+    name: "workout_set_exercise_to_split_id_fkey",
+    columns: [
+      t.exerciseToSplitId
+    ],
+    foreignColumns: [
+      exerciseToWorkoutSplit.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  index2("workout_set_exercise_to_split_id_idx").on(t.exerciseToSplitId),
+  ...workoutSetPolicies(t)
+]);
+var workoutSetRelations = relations3(workoutSet, ({ one }) => ({
+  exerciseToWorkoutSplit: one(exerciseToWorkoutSplit, {
+    fields: [
+      workoutSet.exerciseToSplitId
+    ],
+    references: [
+      exerciseToWorkoutSplit.id
+    ]
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/workout/exercisetoworkoutsplit/policies.ts
+import { sql as drizzleSql6 } from "drizzle-orm";
+import { pgPolicy as pgPolicy4 } from "drizzle-orm/pg-core";
+var uid4 = drizzleSql6`"identity"."current_user_id"()`;
+function exerciseToWorkoutSplitPolicies(t) {
+  const owns = drizzleSql6`${uid4} = (select wp."user_id" from "workout"."workout_plan" wp join "workout"."workout_split" ws on ws."workout_id" = wp."id" where ws."id" = ${t.workoutSplitId})`;
+  const ownsForDelete = drizzleSql6`exists (select 1 from "workout"."workout_split" ws join "workout"."workout_plan" wp on wp."id" = ws."workout_id" where ws."id" = ${t.workoutSplitId} and wp."user_id" = ${uid4})`;
+  return [
+    // Lets authenticated users read exercise assignments in splits they own.
+    pgPolicy4("Enable read access for auth users on exercise_to_workout_split", {
+      for: "select",
+      to: authenticatedRole,
+      using: owns
+    }),
+    // Lets authenticated users add exercise assignments only to splits they own.
+    pgPolicy4("Enable insert for auth users on exercise_to_workout_split", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: owns
+    }),
+    // Lets authenticated users update exercise assignments only in splits they own.
+    pgPolicy4("Enable update for auth users on exercise_to_workout_split", {
+      for: "update",
+      to: authenticatedRole,
+      using: owns,
+      withCheck: owns
+    }),
+    // Lets authenticated users delete exercise assignments only from splits they own.
+    pgPolicy4("Enable delete for auth users on exercise_to_workout_split", {
+      for: "delete",
+      to: authenticatedRole,
+      using: ownsForDelete
+    })
+  ];
+}
+__name(exerciseToWorkoutSplitPolicies, "exerciseToWorkoutSplitPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/workout/exercisetoworkoutsplit/table.ts
+var exerciseToWorkoutSplit = workoutSchema.table("exercise_to_workout_split", {
+  id: bigint2("id", {
+    mode: "number"
+  }).generatedByDefaultAsIdentity({
+    name: "exercise_to_workout_split_id_seq"
+  }).notNull(),
+  workoutSplitId: bigint2("workout_split_id", {
+    mode: "number"
+  }).notNull(),
+  exerciseId: bigint2("exercise_id", {
+    mode: "number"
+  }).notNull(),
+  createdAt: timestamp3("created_at", {
+    withTimezone: true
+  }).default(drizzleSql7`(now() AT TIME ZONE 'utc')`).notNull(),
+  orderIndex: bigint2("order_index", {
+    mode: "number"
+  }).notNull(),
+  isActive: boolean3("is_active").default(true).notNull()
+}, (t) => [
+  primaryKey4({
+    name: "exercise_to_workout_split_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  unique2("uq_exercise_to_workout_split_workout_split_exercise").on(t.workoutSplitId, t.exerciseId),
+  foreignKey4({
+    name: "exercise_to_workout_split_exercise_id_fkey",
+    columns: [
+      t.exerciseId
+    ],
+    foreignColumns: [
+      exercise.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  foreignKey4({
+    name: "exercise_to_workout_split_workout_split_id_fkey",
+    columns: [
+      t.workoutSplitId
+    ],
+    foreignColumns: [
+      workoutSplit.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  index3("exercise_to_workout_split_active_idx").on(t.workoutSplitId, t.orderIndex).where(drizzleSql7`${t.isActive} = true`),
+  index3("exercise_to_workout_split_workout_split_id_order_index_idx").on(t.workoutSplitId, t.orderIndex),
+  ...exerciseToWorkoutSplitPolicies(t)
+]);
+var exerciseToWorkoutSplitRelations = relations4(exerciseToWorkoutSplit, ({ many, one }) => ({
+  exercise: one(exercise, {
+    fields: [
+      exerciseToWorkoutSplit.exerciseId
+    ],
+    references: [
+      exercise.id
+    ]
+  }),
+  workoutSplit: one(workoutSplit, {
+    fields: [
+      exerciseToWorkoutSplit.workoutSplitId
+    ],
+    references: [
+      workoutSplit.id
+    ]
+  }),
+  exerciseTrackings: many(exerciseTracking),
+  workoutSets: many(workoutSet)
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/workout/exercises/policies.ts
+import { sql as drizzleSql8 } from "drizzle-orm";
+import { pgPolicy as pgPolicy5 } from "drizzle-orm/pg-core";
+var exercisePolicies = /* @__PURE__ */ __name(() => [
+  // Makes the shared exercise catalog readable to every authenticated user.
+  pgPolicy5("Allow all authenticated users to read exercise", {
+    for: "select",
+    to: authenticatedRole,
+    using: drizzleSql8`true`
+  })
+], "exercisePolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/workout/exercises/table.ts
+var exercise = workoutSchema.table("exercise", {
+  id: bigint3("id", {
+    mode: "number"
+  }).generatedByDefaultAsIdentity({
+    name: "exercise_id_seq"
+  }).notNull(),
+  name: text3("name").notNull(),
+  description: text3("description").notNull(),
+  targetMuscle: text3("target_muscle").notNull(),
+  specificTargetMuscle: text3("specific_target_muscle").notNull()
+}, (t) => [
+  primaryKey5({
+    name: "exercise_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  uniqueIndex("exercise_name_unique").on(t.name),
+  ...exercisePolicies()
+]);
+var exerciseRelations = relations5(exercise, ({ many }) => ({
+  workoutSplitAssignments: many(exerciseToWorkoutSplit)
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/tracking_set/table.ts
+import { relations as relations6 } from "drizzle-orm";
+import { bigint as bigint4, foreignKey as foreignKey5, index as index4, integer as integer3, primaryKey as primaryKey6, real, unique as unique3, uuid as uuid4 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/tracking_set/policies.ts
+import { sql as drizzleSql9 } from "drizzle-orm";
+import { pgPolicy as pgPolicy6 } from "drizzle-orm/pg-core";
+var currentUserId2 = drizzleSql9`"identity"."current_user_id"()`;
+function trackingSetPolicies(table) {
+  const ownsExerciseTracking = drizzleSql9`exists (
+    select 1
+    from "tracking"."exercise_tracking" et
+    join "tracking"."workout_summary" ws on ws."id" = et."workout_summary_id"
+    where et."id" = ${table.exerciseTrackingId}
+      and ws."user_id" = ${currentUserId2}
+  )`;
+  return [
+    // Lets authenticated users read tracked sets only from workout summaries they own.
+    pgPolicy6("Enable read access for auth users on tracking_set", {
+      for: "select",
+      to: authenticatedRole,
+      using: ownsExerciseTracking
+    }),
+    // Lets authenticated users add tracked sets only to their own exercise tracking rows.
+    pgPolicy6("Enable insert for auth users on tracking_set", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: ownsExerciseTracking
+    }),
+    // Lets authenticated users update tracked sets without moving them outside their own workout.
+    pgPolicy6("Enable update for auth users on tracking_set", {
+      for: "update",
+      to: authenticatedRole,
+      using: ownsExerciseTracking,
+      withCheck: ownsExerciseTracking
+    }),
+    // Lets authenticated users delete tracked sets only from workout summaries they own.
+    pgPolicy6("Enable delete for auth users on tracking_set", {
+      for: "delete",
+      to: authenticatedRole,
+      using: ownsExerciseTracking
+    })
+  ];
+}
+__name(trackingSetPolicies, "trackingSetPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/tracking_set/table.ts
+var trackingSet = trackingSchema.table("tracking_set", {
+  id: uuid4("id").defaultRandom().notNull(),
+  exerciseTrackingId: bigint4("exercise_tracking_id", {
+    mode: "number"
+  }).notNull(),
+  setIndex: integer3("set_index").notNull(),
+  reps: integer3("reps").notNull(),
+  weight: real("weight").notNull()
+}, (t) => [
+  primaryKey6({
+    name: "tracking_set_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  unique3("tracking_set_exercise_index_unique").on(t.exerciseTrackingId, t.setIndex),
+  foreignKey5({
+    name: "tracking_set_exercise_tracking_id_fkey",
+    columns: [
+      t.exerciseTrackingId
+    ],
+    foreignColumns: [
+      exerciseTracking.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  index4("tracking_set_exercise_tracking_id_idx").on(t.exerciseTrackingId),
+  ...trackingSetPolicies(t)
+]);
+var trackingSetRelations = relations6(trackingSet, ({ one }) => ({
+  exerciseTracking: one(exerciseTracking, {
+    fields: [
+      trackingSet.exerciseTrackingId
+    ],
+    references: [
+      exerciseTracking.id
+    ]
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/exercise_tracking/policies.ts
+import { sql as drizzleSql10 } from "drizzle-orm";
+import { pgPolicy as pgPolicy7 } from "drizzle-orm/pg-core";
+var uid5 = drizzleSql10`"identity"."current_user_id"()`;
+function exerciseTrackingPolicies(t) {
+  const owns = drizzleSql10`exists (select 1 from "tracking"."workout_summary" ws where ws."id" = ${t.workoutSummaryId} and ws."user_id" = ${uid5})`;
+  return [
+    // Lets authenticated users read exercise tracking rows through summaries they own.
+    pgPolicy7("exercise_tracking_select_by_summary_owner", {
+      for: "select",
+      to: authenticatedRole,
+      using: owns
+    }),
+    // Lets authenticated users insert exercise tracking rows through summaries they own.
+    pgPolicy7("exercise_tracking_insert_by_summary_owner", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: owns
+    }),
+    // Lets authenticated users update exercise tracking rows through summaries they own.
+    pgPolicy7("exercise_tracking_update_by_summary_owner", {
+      for: "update",
+      to: authenticatedRole,
+      using: owns,
+      withCheck: owns
+    }),
+    // Lets authenticated users delete exercise tracking rows through summaries they own.
+    pgPolicy7("exercise_tracking_delete_by_summary_owner", {
+      for: "delete",
+      to: authenticatedRole,
+      using: owns
+    })
+  ];
+}
+__name(exerciseTrackingPolicies, "exerciseTrackingPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/exercise_tracking/table.ts
+import { check } from "drizzle-orm/pg-core";
+var exerciseTracking = trackingSchema.table("exercise_tracking", {
+  id: bigint5("id", {
+    mode: "number"
+  }).generatedByDefaultAsIdentity({
+    name: "exercise_tracking_id_seq"
+  }).notNull(),
+  workoutSummaryId: uuid5("workout_summary_id").notNull(),
+  exerciseToSplitId: bigint5("exercise_to_split_id", {
+    mode: "number"
+  }),
+  exerciseId: bigint5("exercise_id", {
+    mode: "number"
+  }),
+  notes: text4("notes")
+}, (t) => [
+  primaryKey7({
+    name: "exercise_tracking_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  foreignKey6({
+    name: "exercise_tracking_exercise_to_split_id_fkey",
+    columns: [
+      t.exerciseToSplitId
+    ],
+    foreignColumns: [
+      exerciseToWorkoutSplit.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  foreignKey6({
+    name: "exercise_tracking_exercise_id_fkey",
+    columns: [
+      t.exerciseId
+    ],
+    foreignColumns: [
+      exercise.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  foreignKey6({
+    name: "exercise_tracking_workout_summary_id_fkey",
+    columns: [
+      t.workoutSummaryId
+    ],
+    foreignColumns: [
+      workoutSummary.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  check("exercise_tracking_xor_check", drizzleSql11`num_nonnulls(${t.exerciseToSplitId}, ${t.exerciseId}) = 1`),
+  index5("exercise_tracking_workout_summary_id_idx").on(t.workoutSummaryId),
+  ...exerciseTrackingPolicies(t)
+]);
+var exerciseTrackingRelations = relations7(exerciseTracking, ({ many, one }) => ({
+  exerciseToWorkoutSplit: one(exerciseToWorkoutSplit, {
+    fields: [
+      exerciseTracking.exerciseToSplitId
+    ],
+    references: [
+      exerciseToWorkoutSplit.id
+    ]
+  }),
+  workoutSummary: one(workoutSummary, {
+    fields: [
+      exerciseTracking.workoutSummaryId
+    ],
+    references: [
+      workoutSummary.id
+    ]
+  }),
+  trackingSets: many(trackingSet),
+  exercise: one(exercise, {
+    fields: [
+      exerciseTracking.exerciseId
+    ],
+    references: [
+      exercise.id
+    ]
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/workout_summary/policies.ts
+import { sql as drizzleSql12 } from "drizzle-orm";
+import { pgPolicy as pgPolicy8 } from "drizzle-orm/pg-core";
+var uid6 = drizzleSql12`"identity"."current_user_id"()`;
+function workoutSummaryPolicies(t) {
+  return [
+    // Lets authenticated users read only their own completed workout summaries.
+    pgPolicy8("users can read their workout summaries", {
+      for: "select",
+      to: authenticatedRole,
+      using: drizzleSql12`${t.userId} = ${uid6}`
+    }),
+    // Lets authenticated users insert completed workout summaries only for themselves.
+    pgPolicy8("users can insert their workout summaries", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: drizzleSql12`${t.userId} = ${uid6}`
+    }),
+    // Lets authenticated users update only their own completed workout summaries.
+    pgPolicy8("users can update their workout summaries", {
+      for: "update",
+      to: authenticatedRole,
+      using: drizzleSql12`${t.userId} = ${uid6}`,
+      withCheck: drizzleSql12`${t.userId} = ${uid6}`
+    }),
+    // Lets authenticated users delete only their own completed workout summaries.
+    pgPolicy8("users can delete their workout summaries", {
+      for: "delete",
+      to: authenticatedRole,
+      using: drizzleSql12`${t.userId} = ${uid6}`
+    })
+  ];
+}
+__name(workoutSummaryPolicies, "workoutSummaryPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/workout_summary/table.ts
+var workoutSummary = trackingSchema.table("workout_summary", {
+  id: uuid6("id").defaultRandom().notNull(),
+  userId: uuid6("user_id").notNull(),
+  workoutSplitId: bigint6("workout_split_id", {
+    mode: "number"
+  }).notNull(),
+  workoutStartUtc: timestamp4("workout_start_utc", {
+    withTimezone: true
+  }).notNull(),
+  workoutEndUtc: timestamp4("workout_end_utc", {
+    withTimezone: true
+  }).notNull(),
+  createdAt: timestamp4("created_at", {
+    withTimezone: true
+  }).defaultNow().notNull()
+}, (t) => [
+  primaryKey8({
+    name: "workout_summary_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  foreignKey7({
+    name: "workout_summary_user_id_fkey",
+    columns: [
+      t.userId
+    ],
+    foreignColumns: [
+      user.id
+    ]
+  }).onDelete("cascade"),
+  foreignKey7({
+    name: "workout_summary_workout_split_id_fkey",
+    columns: [
+      t.workoutSplitId
+    ],
+    foreignColumns: [
+      workoutSplit.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  index6("workout_summary_start_date_idx").on(drizzleSql13`((${t.workoutStartUtc} at time zone 'UTC')::date)`),
+  index6("workout_summary_user_start_utc_idx").on(t.userId, t.workoutStartUtc.desc().nullsFirst()),
+  ...workoutSummaryPolicies(t)
+]);
+var workoutSummaryRelations = relations8(workoutSummary, ({ many, one }) => ({
+  user: one(user, {
+    fields: [
+      workoutSummary.userId
+    ],
+    references: [
+      user.id
+    ]
+  }),
+  workoutSplit: one(workoutSplit, {
+    fields: [
+      workoutSummary.workoutSplitId
+    ],
+    references: [
+      workoutSplit.id
+    ]
+  }),
+  exerciseTrackings: many(exerciseTracking)
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_plan/table.ts
+import { relations as relations9, sql as drizzleSql15 } from "drizzle-orm";
+import { bigint as bigint7, boolean as boolean4, foreignKey as foreignKey8, primaryKey as primaryKey9, timestamp as timestamp5, uniqueIndex as uniqueIndex2, uuid as uuid7 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_plan/policies.ts
+import { sql as drizzleSql14 } from "drizzle-orm";
+import { pgPolicy as pgPolicy9 } from "drizzle-orm/pg-core";
+var uid7 = drizzleSql14`"identity"."current_user_id"()`;
+function workoutPlanPolicies(t) {
+  return [
+    // Lets authenticated users read only workout plans they own.
+    pgPolicy9("Enable read access for auth users on workout_plan", {
+      for: "select",
+      to: authenticatedRole,
+      using: drizzleSql14`${uid7} = ${t.userId}`
+    }),
+    // Lets authenticated users create workout plans only for themselves.
+    pgPolicy9("Enable insert for auth users on workout_plan", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: drizzleSql14`${uid7} = ${t.userId}`
+    }),
+    // Lets authenticated users update only workout plans they own.
+    pgPolicy9("Enable update for auth users on workout_plan", {
+      for: "update",
+      to: authenticatedRole,
+      using: drizzleSql14`${uid7} = ${t.userId}`,
+      withCheck: drizzleSql14`${uid7} = ${t.userId}`
+    }),
+    // Lets authenticated users delete only workout plans they own.
+    pgPolicy9("Enable delete for auth users on workout_plan", {
+      for: "delete",
+      to: authenticatedRole,
+      using: drizzleSql14`${uid7} = ${t.userId}`
+    })
+  ];
+}
+__name(workoutPlanPolicies, "workoutPlanPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_plan/table.ts
+var workoutPlan = workoutSchema.table("workout_plan", {
+  id: bigint7("id", {
+    mode: "number"
+  }).generatedByDefaultAsIdentity({
+    name: "workout_plan_id_seq"
+  }).notNull(),
+  userId: uuid7("user_id").notNull(),
+  isActive: boolean4("is_active").default(true).notNull(),
+  updatedAt: timestamp5("updated_at", {
+    withTimezone: true
+  }).default(drizzleSql15`(now() AT TIME ZONE 'utc')`).notNull(),
+  createdAt: timestamp5("created_at", {
+    withTimezone: true
+  }).defaultNow().notNull()
+}, (t) => [
+  primaryKey9({
+    name: "workout_plan_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  foreignKey8({
+    name: "workout_plan_user_id_fkey",
+    columns: [
+      t.userId
+    ],
+    foreignColumns: [
+      user.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  uniqueIndex2("uq_workout_plan_active_user").on(t.userId).where(drizzleSql15`${t.isActive}`),
+  ...workoutPlanPolicies(t)
+]);
+var workoutPlanRelations = relations9(workoutPlan, ({ many, one }) => ({
+  owner: one(user, {
+    fields: [
+      workoutPlan.userId
+    ],
+    references: [
+      user.id
+    ],
+    relationName: "workoutPlanOwner"
+  }),
+  splits: many(workoutSplit)
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_split/policies.ts
+import { sql as drizzleSql16 } from "drizzle-orm";
+import { pgPolicy as pgPolicy10 } from "drizzle-orm/pg-core";
+var uid8 = drizzleSql16`"identity"."current_user_id"()`;
+function workoutSplitPolicies(t) {
+  const owns = drizzleSql16`${uid8} = (select wp."user_id" from "workout"."workout_plan" wp where wp."id" = ${t.workoutId})`;
+  const ownsForDelete = drizzleSql16`exists (select 1 from "workout"."workout_plan" wp where wp."id" = ${t.workoutId} and wp."user_id" = ${uid8})`;
+  return [
+    // Lets authenticated users read splits belonging to their own plans.
+    pgPolicy10("Enable read access for auth users on workout_split", {
+      for: "select",
+      to: authenticatedRole,
+      using: owns
+    }),
+    // Lets authenticated users add splits only to their own plans.
+    pgPolicy10("Enable insert for auth users on workout_split", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: owns
+    }),
+    // Lets authenticated users update splits only within their own plans.
+    pgPolicy10("Enable update for auth users on workout_split", {
+      for: "update",
+      to: authenticatedRole,
+      using: owns,
+      withCheck: owns
+    }),
+    // Lets authenticated users delete splits only from their own plans.
+    pgPolicy10("Enable delete for auth users on workout_split", {
+      for: "delete",
+      to: authenticatedRole,
+      using: ownsForDelete
+    })
+  ];
+}
+__name(workoutSplitPolicies, "workoutSplitPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/workout/workout_split/table.ts
+var workoutSplit = workoutSchema.table("workout_split", {
+  id: bigint8("id", {
+    mode: "number"
+  }).generatedByDefaultAsIdentity({
+    name: "workout_split_id_seq"
+  }).notNull(),
+  workoutId: bigint8("workout_id", {
+    mode: "number"
+  }).notNull(),
+  name: text5("name").notNull(),
+  createdAt: timestamp6("created_at", {
+    withTimezone: true
+  }).default(drizzleSql17`(now() AT TIME ZONE 'utc')`).notNull(),
+  isActive: boolean5("is_active").default(true).notNull()
+}, (t) => [
+  primaryKey10({
+    name: "workout_split_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  unique4("uq_workout_split_plan_name").on(t.workoutId, t.name),
+  foreignKey9({
+    name: "workout_split_workout_id_fkey",
+    columns: [
+      t.workoutId
+    ],
+    foreignColumns: [
+      workoutPlan.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  index7("workout_split_workout_id_idx").on(t.workoutId),
+  ...workoutSplitPolicies(t)
+]);
+var workoutSplitRelations = relations10(workoutSplit, ({ many, one }) => ({
+  workoutPlan: one(workoutPlan, {
+    fields: [
+      workoutSplit.workoutId
+    ],
+    references: [
+      workoutPlan.id
+    ]
+  }),
+  exerciseAssignments: many(exerciseToWorkoutSplit),
+  workoutSummaries: many(workoutSummary),
+  splitInformation: many(userSplitInformation)
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/reminders/user_split_information/table.ts
+var userSplitInformation = remindersSchema.table("user_split_information", {
+  id: bigint9("id", {
+    mode: "number"
+  }).generatedByDefaultAsIdentity({
+    name: "user_split_information_id_seq"
+  }).notNull(),
+  userId: uuid8("user_id").notNull(),
+  workoutSplitId: bigint9("workout_split_id", {
+    mode: "number"
+  }).notNull(),
+  estimatedTimeUtc: timestamp7("estimated_time_utc", {
+    withTimezone: true
+  }).notNull(),
+  confidence: numeric("confidence", {
+    precision: 3,
+    scale: 2
+  }).default("1.00").notNull(),
+  lastComputedAt: timestamp7("last_computed_at", {
+    withTimezone: true
+  }).default(drizzleSql18`timezone('UTC', now())`).notNull(),
+  preferredWeekday: integer4("preferred_weekday")
+}, (t) => [
+  primaryKey11({
+    name: "user_split_information_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  unique5("user_split_information_user_id_workout_split_id_key").on(t.userId, t.workoutSplitId),
+  foreignKey10({
+    name: "user_split_information_user_id_fkey",
+    columns: [
+      t.userId
+    ],
+    foreignColumns: [
+      user.id
+    ]
+  }).onDelete("cascade"),
+  foreignKey10({
+    name: "user_split_information_workout_split_id_fkey",
+    columns: [
+      t.workoutSplitId
+    ],
+    foreignColumns: [
+      workoutSplit.id
+    ]
+  }).onDelete("cascade"),
+  index8("user_split_information_confidence_idx").on(t.preferredWeekday, t.confidence).where(drizzleSql18`${t.confidence} >= 0.60`),
+  index8("user_split_information_user_weekday_idx").on(t.userId, t.preferredWeekday).where(drizzleSql18`${t.preferredWeekday} is not null`)
+]).enableRLS();
+var userSplitInformationRelations = relations11(userSplitInformation, ({ one }) => ({
+  user: one(user, {
+    fields: [
+      userSplitInformation.userId
+    ],
+    references: [
+      user.id
+    ]
+  }),
+  workoutSplit: one(workoutSplit, {
+    fields: [
+      userSplitInformation.workoutSplitId
+    ],
+    references: [
+      workoutSplit.id
+    ]
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/aerobic_tracking/table.ts
+import { relations as relations12, sql as drizzleSql20 } from "drizzle-orm";
+import { bigint as bigint10, foreignKey as foreignKey11, index as index9, primaryKey as primaryKey12, text as text6, timestamp as timestamp8, uuid as uuid9 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/aerobic_tracking/policies.ts
+import { sql as drizzleSql19 } from "drizzle-orm";
+import { pgPolicy as pgPolicy11 } from "drizzle-orm/pg-core";
+var uid9 = drizzleSql19`"identity"."current_user_id"()`;
+function aerobicTrackingPolicies(t) {
+  return [
+    // Lets authenticated users read only their own aerobic tracking rows.
+    pgPolicy11("Enable read access for auth users on aerobic_tracking", {
+      for: "select",
+      to: authenticatedRole,
+      using: drizzleSql19`${uid9} = ${t.userId}`
+    }),
+    // Lets authenticated users insert aerobic tracking rows only for themselves.
+    pgPolicy11("Enable insert for auth users on aerobic_tracking", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: drizzleSql19`${uid9} = ${t.userId}`
+    }),
+    // Lets authenticated users update only their own aerobic tracking rows.
+    pgPolicy11("Enable update for auth users on aerobic_tracking", {
+      for: "update",
+      to: authenticatedRole,
+      using: drizzleSql19`${uid9} = ${t.userId}`,
+      withCheck: drizzleSql19`${uid9} = ${t.userId}`
+    }),
+    // Lets authenticated users delete only their own aerobic tracking rows.
+    pgPolicy11("Enable delete for auth users on aerobic_tracking", {
+      for: "delete",
+      to: authenticatedRole,
+      using: drizzleSql19`${uid9} = ${t.userId}`
+    })
+  ];
+}
+__name(aerobicTrackingPolicies, "aerobicTrackingPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/tracking/aerobic_tracking/table.ts
+var aerobicTracking = trackingSchema.table("aerobic_tracking", {
+  id: bigint10("id", {
+    mode: "number"
+  }).generatedByDefaultAsIdentity({
+    name: "aerobic_tracking_id_seq"
+  }).notNull(),
+  userId: uuid9("user_id").notNull(),
+  type: text6("type").notNull(),
+  durationSec: bigint10("duration_sec", {
+    mode: "number"
+  }).default(0).notNull(),
+  workoutTimeUtc: timestamp8("workout_time_utc", {
+    withTimezone: true
+  }).default(drizzleSql20`(now() AT TIME ZONE 'utc')`).notNull()
+}, (t) => [
+  primaryKey12({
+    name: "aerobic_tracking_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  foreignKey11({
+    name: "aerobic_tracking_user_id_fkey",
+    columns: [
+      t.userId
+    ],
+    foreignColumns: [
+      user.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  index9("aerobic_tracking_user_id_workout_time_utc_idx").on(t.userId, t.workoutTimeUtc.desc().nullsFirst()),
+  ...aerobicTrackingPolicies(t)
+]);
+var aerobicTrackingRelations = relations12(aerobicTracking, ({ one }) => ({
+  user: one(user, {
+    fields: [
+      aerobicTracking.userId
+    ],
+    references: [
+      user.id
+    ]
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/identity/oauth_account/table.ts
+import { relations as relations13, sql as drizzleSql22 } from "drizzle-orm";
+import { foreignKey as foreignKey12, primaryKey as primaryKey13, text as text7, timestamp as timestamp9, unique as unique6, uuid as uuid10 } from "drizzle-orm/pg-core";
+
+// ../../src/infrastructure/db/schema/drizzle/identity/oauth_account/policies.ts
+import { sql as drizzleSql21 } from "drizzle-orm";
+import { pgPolicy as pgPolicy12 } from "drizzle-orm/pg-core";
+var currentUserId3 = drizzleSql21`"identity"."current_user_id"()`;
+function oauthAccountPolicies(table) {
+  return [
+    // Lets authenticated users read only OAuth accounts linked to themselves.
+    pgPolicy12("Enable read access for auth users on oauth_account", {
+      for: "select",
+      to: authenticatedRole,
+      using: drizzleSql21`${currentUserId3} = ${table.userId}`
+    }),
+    // Lets authenticated users link OAuth accounts only to themselves.
+    pgPolicy12("Enable insert for auth users on oauth_account", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: drizzleSql21`${currentUserId3} = ${table.userId}`
+    }),
+    // Lets authenticated users update only OAuth accounts linked to themselves.
+    pgPolicy12("Enable update for auth users on oauth_account", {
+      for: "update",
+      to: authenticatedRole,
+      using: drizzleSql21`${currentUserId3} = ${table.userId}`,
+      withCheck: drizzleSql21`${currentUserId3} = ${table.userId}`
+    }),
+    // Lets authenticated users delete only OAuth accounts linked to themselves.
+    pgPolicy12("Enable delete for auth users on oauth_account", {
+      for: "delete",
+      to: authenticatedRole,
+      using: drizzleSql21`${currentUserId3} = ${table.userId}`
+    })
+  ];
+}
+__name(oauthAccountPolicies, "oauthAccountPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/identity/oauth_account/table.ts
+var oauthAccount = identitySchema.table("oauth_account", {
+  id: uuid10("id").defaultRandom().notNull(),
+  userId: uuid10("user_id").notNull(),
+  provider: text7("provider").notNull(),
+  providerUserId: text7("provider_user_id").notNull(),
+  providerEmail: text7("provider_email").notNull(),
+  linkedAt: timestamp9("linked_at", {
+    withTimezone: true
+  }).default(drizzleSql22`(now() AT TIME ZONE 'utc')`).notNull(),
+  missingFields: text7("missing_fields")
+}, (t) => [
+  primaryKey13({
+    name: "oauth_account_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  unique6("oauth_account_provider_user_unique").on(t.provider, t.providerUserId),
+  foreignKey12({
+    name: "oauth_account_user_id_fkey",
+    columns: [
+      t.userId
+    ],
+    foreignColumns: [
+      user.id
+    ]
+  }).onUpdate("cascade").onDelete("cascade"),
+  ...oauthAccountPolicies(t)
+]);
+var oauthAccountRelations = relations13(oauthAccount, ({ one }) => ({
+  user: one(user, {
+    fields: [
+      oauthAccount.userId
+    ],
+    references: [
+      user.id
+    ]
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/identity/user/policies.ts
+import { sql as drizzleSql23 } from "drizzle-orm";
+import { pgPolicy as pgPolicy13 } from "drizzle-orm/pg-core";
+var currentUserId4 = drizzleSql23`"identity"."current_user_id"()`;
+function userPolicies(table) {
+  return [
+    // Lets an authenticated user read their own profile.
+    pgPolicy13("Enable read access for auth users on own profile", {
+      for: "select",
+      to: authenticatedRole,
+      using: drizzleSql23`${currentUserId4} = ${table.id}`
+    }),
+    // Lets a message receiver read the profile of a sender in their inbox.
+    pgPolicy13("Allow user to view senders in their messages", {
+      for: "select",
+      to: authenticatedRole,
+      using: drizzleSql23`exists (select 1 from "messages"."message" m where m."sender_id" = ${table.id} and m."receiver_id" = ${currentUserId4})`
+    }),
+    // Lets an authenticated user create only their own profile row.
+    pgPolicy13("Enable insert for auth users on own profile", {
+      for: "insert",
+      to: authenticatedRole,
+      withCheck: drizzleSql23`${currentUserId4} = ${table.id}`
+    }),
+    // Preserves the legacy public self-registration policy for compatibility.
+    pgPolicy13("Enable insert for public users on own profile", {
+      for: "insert",
+      to: "public",
+      withCheck: drizzleSql23`${currentUserId4} = ${table.id}`
+    }),
+    // Lets an authenticated user update only their own profile.
+    pgPolicy13("Enable update for auth users on own profile", {
+      for: "update",
+      to: authenticatedRole,
+      using: drizzleSql23`${currentUserId4} = ${table.id}`,
+      withCheck: drizzleSql23`${currentUserId4} = ${table.id}`
+    }),
+    // Lets an authenticated user delete only their own profile.
+    pgPolicy13("Enable delete for auth users on own profile", {
+      for: "delete",
+      to: authenticatedRole,
+      using: drizzleSql23`${currentUserId4} = ${table.id}`
+    })
+  ];
+}
+__name(userPolicies, "userPolicies");
+
+// ../../src/infrastructure/db/schema/drizzle/identity/user/table.ts
+var user = identitySchema.table("user", {
+  username: text8("username").notNull(),
+  email: text8("email").notNull(),
+  name: text8("name").notNull(),
+  gender: text8("gender").default("Unknown").notNull(),
+  createdAt: timestamp10("created_at", {
+    withTimezone: true
+  }).default(drizzleSql24`(now() AT TIME ZONE 'utc')`).notNull(),
+  updatedAt: timestamp10("updated_at", {
+    withTimezone: true
+  }).default(drizzleSql24`(now() AT TIME ZONE 'utc')`).notNull(),
+  profilePicPath: text8("profile_pic_path"),
+  id: uuid11("id").defaultRandom().notNull(),
+  pushToken: text8("push_token"),
+  passwordHash: text8("password_hash"),
+  role: text8("role").default("User").notNull(),
+  tokenVersion: bigint11("token_version", {
+    mode: "number"
+  }).default(0).notNull(),
+  isVerified: boolean6("is_verified").default(false).notNull(),
+  authProvider: text8("auth_provider").default("app").notNull(),
+  lastLogin: timestamp10("last_login", {
+    withTimezone: true
+  })
+}, (t) => [
+  primaryKey14({
+    name: "user_pkey",
+    columns: [
+      t.id
+    ]
+  }),
+  uniqueIndex3("user_email_ci_unique").on(drizzleSql24`lower(trim(both from ${t.email}))`),
+  uniqueIndex3("user_username_ci_unique").on(drizzleSql24`lower(trim(both from ${t.username}))`),
+  ...userPolicies(t)
+]);
+var userRelations = relations14(user, ({ many, one }) => ({
+  oauthAccounts: many(oauthAccount),
+  ownedWorkoutPlans: many(workoutPlan, {
+    relationName: "workoutPlanOwner"
+  }),
+  trainedWorkoutPlans: many(workoutPlan, {
+    relationName: "workoutPlanTrainer"
+  }),
+  workoutSummaries: many(workoutSummary),
+  aerobicTrackings: many(aerobicTracking),
+  reminderSettings: one(userReminderSetting),
+  splitInformation: many(userSplitInformation),
+  sentMessages: many(message, {
+    relationName: "messageSender"
+  }),
+  receivedMessages: many(message, {
+    relationName: "messageReceiver"
+  })
+}));
+
+// ../../src/infrastructure/db/schema/drizzle/workout/views/exercise-to-workoutsplit-expanded.view.ts
+import { bigint as bigint12, boolean as boolean7, text as text9, timestamp as timestamp11 } from "drizzle-orm/pg-core";
+import { sql as drizzleSql25 } from "drizzle-orm";
+import { integer as integer5 } from "drizzle-orm/pg-core";
+var exerciseToWorkoutSplitExpandedView = workoutSchema.view("v_exercise_to_workout_split_expanded", {
+  id: bigint12("id", {
+    mode: "number"
+  }),
+  workoutSplitId: bigint12("workout_split_id", {
+    mode: "number"
+  }),
+  workoutId: bigint12("workout_id", {
+    mode: "number"
+  }),
+  exerciseId: bigint12("exercise_id", {
+    mode: "number"
+  }),
+  exercise: text9("exercise"),
+  workoutSplit: text9("workout_split"),
+  reps: integer5("reps"),
+  orderIndex: bigint12("order_index", {
+    mode: "number"
+  }),
+  setOrderIndex: integer5("set_order_index"),
+  createdAt: timestamp11("created_at", {
+    withTimezone: true
+  }),
+  isActive: boolean7("is_active")
+}).with({
+  securityInvoker: true
+}).as(drizzleSql25`
+    SELECT
+      ews.id,
+      ews.workout_split_id,
+      ws.workout_id,
+      ews.exercise_id,
+      ex.name AS exercise,
+      ws.name AS workout_split,
+      workout_set.reps AS reps,
+      workout_set.order_index AS set_order_index,
+      ews.order_index,
+      ews.created_at,
+      ews.is_active
+    FROM
+      workout.exercise_to_workout_split ews
+      JOIN workout.workout_split ws ON ws.id = ews.workout_split_id
+      JOIN workout.exercise ex ON ex.id = ews.exercise_id
+      LEFT JOIN workout.workout_set workout_set ON workout_set.exercise_to_split_id = ews.id
+    GROUP BY
+      ews.id,
+      ews.workout_split_id,
+      ws.workout_id,
+      ews.exercise_id,
+      ex.name,
+      ws.name,
+      workout_set.reps,
+      workout_set.order_index,
+      ews.order_index,
+      ews.created_at,
+      ews.is_active
+  `);
+
+// ../../src/infrastructure/db/schema/drizzle/analytics/views/exercise-tracking-expanded.view.ts
+import { sql as drizzleSql26 } from "drizzle-orm";
+import { bigint as bigint13, real as real2, text as text10, timestamp as timestamp12, uuid as uuid12 } from "drizzle-orm/pg-core";
+import { integer as integer6 } from "drizzle-orm/pg-core";
+var exerciseTrackingExpandedView = analyticsSchema.view("v_exercise_tracking_expanded", {
+  id: bigint13("id", {
+    mode: "number"
+  }),
+  exerciseToSplitId: bigint13("exercise_to_split_id", {
+    mode: "number"
+  }),
+  weight: real2("weight"),
+  reps: bigint13("reps", {
+    mode: "number"
+  }),
+  setIndex: integer6("set_index"),
+  exerciseId: bigint13("exercise_id", {
+    mode: "number"
+  }),
+  workoutSplitId: bigint13("workout_split_id", {
+    mode: "number"
+  }),
+  splitName: text10("split_name"),
+  exercise: text10("exercise"),
+  notes: text10("notes"),
+  workoutSummaryId: uuid12("workout_summary_id"),
+  workoutStartUtc: timestamp12("workout_start_utc", {
+    withTimezone: true
+  }),
+  workoutEndUtc: timestamp12("workout_end_utc", {
+    withTimezone: true
+  })
+}).with({
+  securityInvoker: true
+}).as(drizzleSql26`
+    SELECT
+      et.id,
+      et.exercise_to_split_id,
+      tracking_set.weight AS weight,
+      tracking_set.reps AS reps,
+      tracking_set.set_index AS set_index,
+      COALESCE(ews.exercise_id, et.exercise_id) AS exercise_id,
+      wsumm.workout_split_id,
+      ws.name AS split_name,
+      ex.name AS exercise,
+      et.notes,
+      et.workout_summary_id,
+      wsumm.workout_start_utc,
+      wsumm.workout_end_utc
+    FROM
+      tracking.exercise_tracking et
+      LEFT JOIN tracking.workout_summary wsumm ON wsumm.id = et.workout_summary_id
+      LEFT JOIN workout.exercise_to_workout_split ews ON ews.id = et.exercise_to_split_id
+      LEFT JOIN workout.workout_split ws ON ws.id = wsumm.workout_split_id
+      LEFT JOIN workout.exercise ex ON ex.id = COALESCE(ews.exercise_id, et.exercise_id)
+      LEFT JOIN tracking.tracking_set tracking_set ON tracking_set.exercise_tracking_id = et.id
+  `);
+
+// ../../src/infrastructure/db/schema/drizzle/analytics/views/prs.view.ts
+import { sql as drizzleSql27 } from "drizzle-orm";
+import { bigint as bigint14, real as real3, text as text11, timestamp as timestamp13, uuid as uuid13 } from "drizzle-orm/pg-core";
+var prsView = analyticsSchema.view("v_prs", {
+  id: bigint14("id", {
+    mode: "number"
+  }),
+  exerciseToSplitId: bigint14("exercise_to_split_id", {
+    mode: "number"
+  }),
+  exerciseId: bigint14("exercise_id", {
+    mode: "number"
+  }),
+  exercise: text11("exercise"),
+  weight: real3("weight"),
+  reps: bigint14("reps", {
+    mode: "number"
+  }),
+  workoutSummaryId: uuid13("workout_summary_id"),
+  workoutStartUtc: timestamp13("workout_start_utc", {
+    withTimezone: true
+  }),
+  workoutEndUtc: timestamp13("workout_end_utc", {
+    withTimezone: true
+  })
+}).with({
+  securityInvoker: true
+}).as(drizzleSql27`
+    SELECT DISTINCT
+      ON (et.exercise_id) et.id,
+      et.exercise_to_split_id,
+      et.exercise_id,
+      et.exercise,
+      et.weight,
+      et.reps,
+      et.workout_summary_id,
+      et.workout_start_utc,
+      et.workout_end_utc
+    FROM
+      analytics.v_exercise_tracking_expanded et
+    ORDER BY
+      et.exercise_id,
+      et.weight DESC,
+      et.reps DESC,
+      et.workout_start_utc DESC,
+      et.id DESC
+  `);
+
+// src/database/database.schemas.ts
+var userDbSchema = createSelectSchema(user);
+var userInsertDbSchema = createInsertSchema(user);
+var userUpdateDbSchema = createUpdateSchema(user);
+var oauthAccountDbSchema = createSelectSchema(oauthAccount);
+var exerciseDbSchema = createSelectSchema(exercise);
+var workoutPlanDbSchema = createSelectSchema(workoutPlan);
+var workoutSplitDbSchema = createSelectSchema(workoutSplit);
+var exerciseToWorkoutSplitDbSchema = createSelectSchema(exerciseToWorkoutSplit);
+var exerciseToWorkoutSplitExpandedViewDbSchema = createSelectSchema(exerciseToWorkoutSplitExpandedView);
+var workoutSetDbSchema = createSelectSchema(workoutSet);
+var workoutSummaryDbSchema = createSelectSchema(workoutSummary);
+var exerciseTrackingDbSchema = createSelectSchema(exerciseTracking);
+var trackingSetDbSchema = createSelectSchema(trackingSet);
+var aerobicTrackingDbSchema = createSelectSchema(aerobicTracking);
+var messageDbSchema = createSelectSchema(message);
+var userReminderSettingDbSchema = createSelectSchema(userReminderSetting);
+var userSplitInformationDbSchema = createSelectSchema(userSplitInformation);
+var exerciseTrackingExpandedViewDbSchema = createSelectSchema(exerciseTrackingExpandedView);
+var prsViewDbSchema = createSelectSchema(prsView);
 
 // src/modules/aerobics/aerobics.schemas.ts
-var import_zod = __toESM(require("zod"));
-var addAerobicInput = import_zod.default.object({
-  durationMins: import_zod.default.number(),
-  durationSec: import_zod.default.number(),
-  type: import_zod.default.string()
-});
-var addAerobicsRequest = import_zod.default.object({
-  body: import_zod.default.object({
-    tz: import_zod.default.string(),
+import z2 from "zod/v4";
+var addAerobicInput = z2.object({
+  durationMins: z2.number(),
+  durationSec: aerobicTrackingDbSchema.shape.durationSec,
+  type: aerobicTrackingDbSchema.shape.type
+});
+var addAerobicsRequest = z2.object({
+  body: z2.object({
+    tz: z2.string(),
     record: addAerobicInput
   })
 });
-var getAerobicsRequest = import_zod.default.object({
-  query: import_zod.default.object({
-    tz: import_zod.default.string().optional()
+var getAerobicsRequest = z2.object({
+  query: z2.object({
+    tz: z2.string().optional()
   })
 });
-var aerobicsDailyRecordSchema = import_zod.default.object({
-  type: import_zod.default.string(),
-  duration_sec: import_zod.default.number(),
-  duration_mins: import_zod.default.number()
+var aerobicsDailyRecordSchema = z2.object({
+  type: aerobicTrackingDbSchema.shape.type,
+  durationSec: aerobicTrackingDbSchema.shape.durationSec,
+  durationMins: aerobicTrackingDbSchema.shape.durationSec
 });
 var aerobicsWeeklyRecordSchema = aerobicsDailyRecordSchema.extend({
-  workout_time_utc: import_zod.default.string()
+  workoutTimeUtc: serializedDateSchema
 });
-var weeklyDataSchema = import_zod.default.object({
-  records: import_zod.default.array(aerobicsWeeklyRecordSchema),
-  total_duration_sec: import_zod.default.number(),
-  total_duration_mins: import_zod.default.number()
+var weeklyDataSchema = z2.object({
+  records: z2.array(aerobicsWeeklyRecordSchema),
+  totalDurationSec: z2.number(),
+  totalDurationMins: z2.number()
 });
-var userAerobicsResponseSchema = import_zod.default.object({
-  daily: import_zod.default.record(import_zod.default.string(), import_zod.default.array(aerobicsDailyRecordSchema)),
-  weekly: import_zod.default.record(import_zod.default.string(), weeklyDataSchema)
+var userAerobicsResponseSchema = z2.object({
+  daily: z2.record(z2.string(), z2.array(aerobicsDailyRecordSchema)),
+  weekly: z2.record(z2.string(), weeklyDataSchema)
 });
 
 // src/modules/analytics/analytics.schemas.ts
-var import_zod2 = require("zod");
-var workoutRmRecordSchema = import_zod2.z.object({
-  exercise: import_zod2.z.string(),
-  pr_weight: import_zod2.z.number().nullable(),
-  pr_reps: import_zod2.z.number().nullable(),
-  max_1rm: import_zod2.z.number()
+import { z as z3 } from "zod/v4";
+var workoutRmRecordSchema = z3.object({
+  exercise: exerciseDbSchema.shape.name,
+  prWeight: trackingSetDbSchema.shape.weight.nullable(),
+  prReps: trackingSetDbSchema.shape.reps.nullable(),
+  max1Rm: z3.number()
+});
+var adherenceExerciseStatsSchema = z3.object({
+  planned: z3.number(),
+  actual: z3.number(),
+  adherencePct: z3.number().nullable()
+});
+var getAnalyticsResponseSchema = z3.object({
+  oneRepMaxes: z3.record(z3.string(), workoutRmRecordSchema),
+  goals: z3.record(z3.string(), z3.record(z3.string(), adherenceExerciseStatsSchema))
 });
-var adherenceExerciseStatsSchema = import_zod2.z.object({
-  planned: import_zod2.z.number(),
-  actual: import_zod2.z.number(),
-  adherence_pct: import_zod2.z.number().nullable()
-});
-var getAnalyticsResponseSchema = import_zod2.z.object({
-  _1RM: import_zod2.z.record(import_zod2.z.string(), workoutRmRecordSchema),
-  goals: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.record(import_zod2.z.string(), adherenceExerciseStatsSchema))
+
+// src/modules/auth/password/password.dtos.ts
+import { z as z4 } from "zod/v4";
+var forgotPasswordPayloadSchema = z4.object({
+  sub: userDbSchema.shape.id,
+  jti: z4.string(),
+  exp: z4.number(),
+  iss: z4.string(),
+  typ: z4.string()
 });
 
 // src/modules/auth/password/password.schemas.ts
-var import_zod3 = require("zod");
-var sendChangePassEmailRequest = import_zod3.z.object({
-  body: import_zod3.z.object({ identifier: import_zod3.z.string() })
+import { z as z5 } from "zod/v4";
+var sendChangePassEmailRequest = z5.object({
+  body: z5.object({
+    identifier: z5.string()
+  })
 });
-var resetPasswordRequest = import_zod3.z.object({
-  body: import_zod3.z.object({
-    newPassword: import_zod3.z.string().min(8, "Password must be at least 8 characters long")
+var resetPasswordRequest = z5.object({
+  body: z5.object({
+    newPassword: z5.string().min(8, "Password must be at least 8 characters long")
   }),
-  query: import_zod3.z.object({
-    token: import_zod3.z.string().optional()
+  query: z5.object({
+    token: z5.string().optional()
+  })
+});
+var resetPasswordResponseSchema = z5.object({
+  ok: z5.boolean()
+});
+
+// src/modules/auth/session/session.dtos.ts
+import { z as z7 } from "zod/v4";
+
+// src/modules/user/update/update.schemas.ts
+import { z as z6 } from "zod/v4";
+var updateUserRequest = z6.object({
+  body: z6.object({
+    username: userDbSchema.shape.username.trim().min(3, "Username must be at least 3 characters").max(15, "Username must be at most 15 characters").regex(/^[a-zA-Z0-9_]+$/, "Username may contain letters, numbers, and underscore only"),
+    fullName: userDbSchema.shape.name.trim().min(1, "Full name is required").max(20, "Full name is too long").regex(/^[a-zA-Z\s]+$/, "Full name may contain letters and spaces only"),
+    email: userDbSchema.shape.email.trim().toLowerCase().email("Invalid email format")
+  }).partial()
+});
+var deleteProfilePicRequest = z6.object({
+  body: z6.object({
+    path: z6.string()
   })
 });
-var resetPasswordResponseSchema = import_zod3.z.object({
-  ok: import_zod3.z.boolean()
+var userDataSchema = z6.object({
+  id: userDbSchema.shape.id,
+  username: userDbSchema.shape.username,
+  email: userDbSchema.shape.email,
+  name: userDbSchema.shape.name,
+  gender: userDbSchema.shape.gender,
+  createdAt: serializedDateSchema,
+  updatedAt: serializedDateSchema,
+  profileImageUrl: userDbSchema.shape.profilePicPath,
+  pushToken: userDbSchema.shape.pushToken,
+  role: userDbSchema.shape.role,
+  isFirstLogin: z6.boolean(),
+  tokenVersion: userDbSchema.shape.tokenVersion,
+  isVerified: userDbSchema.shape.isVerified,
+  authProvider: userDbSchema.shape.authProvider,
+  lastLogin: serializedDateSchema.nullable()
+});
+var userDataResponseSchema = z6.object({
+  userData: userDataSchema
+});
+var getAuthenticatedUserByIdResponseSchema = userDataSchema;
+var updateAuthenticatedUserResponseSchema = z6.object({
+  message: z6.string(),
+  emailChanged: z6.boolean(),
+  user: userDataSchema
+});
+var setProfilePicAndUpdateDBResponseSchema = z6.object({
+  path: z6.string(),
+  url: z6.string(),
+  message: z6.string()
+});
+
+// src/modules/auth/session/session.dtos.ts
+var accessTokenPayloadSchema = z7.object({
+  id: userDbSchema.shape.id,
+  role: userDbSchema.shape.role,
+  tokenVer: userDbSchema.shape.tokenVersion,
+  cnf: z7.object({
+    jkt: z7.string()
+  }).optional(),
+  iat: z7.number().optional(),
+  exp: z7.number().optional()
+});
+var userAfterBumpSchema = z7.object({
+  tokenVersion: userDbSchema.shape.tokenVersion,
+  userData: userDataSchema
+});
+var tokenVersionResultSchema = z7.object({
+  tokenVersion: userDbSchema.shape.tokenVersion
 });
 
 // src/modules/auth/session/session.schemas.ts
-var import_zod4 = require("zod");
-var loginRequest = import_zod4.z.object({
-  body: import_zod4.z.object({
-    identifier: import_zod4.z.string().min(3).refine(
-      (val) => {
-        const isEmail = import_zod4.z.string().email().safeParse(val).success;
-        const isUsername = /^[a-zA-Z0-9_]{3,20}$/.test(val);
-        return isEmail || isUsername;
-      },
-      {
-        message: "Must be a valid email or username"
-      }
-    ),
-    password: import_zod4.z.string().min(1, "Username and password are required")
+import { z as z8 } from "zod/v4";
+var loginRequest = z8.object({
+  body: z8.object({
+    identifier: z8.string().min(3).refine((val) => {
+      const isEmail = z8.string().email().safeParse(val).success;
+      const isUsername = /^[a-zA-Z0-9_]{3,20}$/.test(val);
+      return isEmail || isUsername;
+    }, {
+      message: "Must be a valid email or username"
+    }),
+    password: z8.string().min(1, "Username and password are required")
   })
 });
-var loginResponseSchema = import_zod4.z.object({
-  message: import_zod4.z.string(),
-  user: import_zod4.z.string(),
-  accessToken: import_zod4.z.string(),
-  refreshToken: import_zod4.z.string()
+var loginResponseSchema = z8.object({
+  message: z8.string(),
+  user: userDbSchema.shape.id,
+  accessToken: z8.string(),
+  refreshToken: z8.string()
 });
-var logoutResponseSchema = import_zod4.z.object({
-  message: import_zod4.z.string()
+var logoutResponseSchema = z8.object({
+  message: z8.string()
 });
-var refreshTokenResponseSchema = import_zod4.z.object({
-  message: import_zod4.z.string(),
-  accessToken: import_zod4.z.string(),
-  refreshToken: import_zod4.z.string(),
-  userId: import_zod4.z.string()
+var refreshTokenResponseSchema = z8.object({
+  message: z8.string(),
+  accessToken: z8.string(),
+  refreshToken: z8.string(),
+  userId: userDbSchema.shape.id
+});
+
+// src/modules/auth/verification/verification.dtos.ts
+import { z as z9 } from "zod/v4";
+var emailVerifyPayloadSchema = z9.object({
+  sub: userDbSchema.shape.id,
+  jti: z9.string(),
+  exp: z9.number(),
+  iss: z9.string(),
+  typ: z9.string()
 });
 
 // src/modules/auth/verification/verification.schemas.ts
-var import_zod5 = __toESM(require("zod"));
-var verifyAccountRequest = import_zod5.default.object({
-  query: import_zod5.default.object({
-    token: import_zod5.default.string().optional()
+import z10 from "zod/v4";
+var verifyAccountRequest = z10.object({
+  query: z10.object({
+    token: z10.string().optional()
   })
 });
-var sendVerificationMailRequest = import_zod5.default.object({
-  body: import_zod5.default.object({ email: import_zod5.default.string().trim().email("Invalid email") })
+var sendVerificationMailRequest = z10.object({
+  body: z10.object({
+    email: userDbSchema.shape.email.trim().email("Invalid email")
+  })
 });
-var changeEmailAndVerifyRequest = import_zod5.default.object({
-  body: import_zod5.default.object({ username: import_zod5.default.string(), password: import_zod5.default.string(), newEmail: import_zod5.default.string().trim().email("Invalid email") })
+var changeEmailAndVerifyRequest = z10.object({
+  body: z10.object({
+    username: userDbSchema.shape.username,
+    password: z10.string(),
+    newEmail: userDbSchema.shape.email.trim().email("Invalid email")
+  })
 });
-var checkUserVerifyRequest = import_zod5.default.object({
-  query: import_zod5.default.object({ username: import_zod5.default.string() })
+var checkUserVerifyRequest = z10.object({
+  query: z10.object({
+    username: userDbSchema.shape.username
+  })
+});
+
+// src/modules/auth/auth.dtos.ts
+import { z as z11 } from "zod/v4";
+var userByIndetifierSchema = z11.object({
+  id: userDbSchema.shape.id,
+  name: userDbSchema.shape.name,
+  username: userDbSchema.shape.username,
+  email: userDbSchema.shape.email.optional(),
+  password: userDbSchema.shape.passwordHash,
+  role: userDbSchema.shape.role,
+  isVerified: userDbSchema.shape.isVerified,
+  lastLogin: serializedDateSchema.nullable().optional()
 });
 
 // src/modules/bootstrap/bootstrap.schemas.ts
-var import_zod10 = require("zod");
+import { z as z15 } from "zod/v4";
 
 // src/modules/messages/messages.schemas.ts
-var import_zod6 = require("zod");
-var getAllMessagesRequest = import_zod6.z.object({
-  query: import_zod6.z.object({
-    tz: import_zod6.z.string()
+import { z as z12 } from "zod/v4";
+var getAllMessagesRequest = z12.object({
+  query: z12.object({
+    tz: z12.string()
   })
 });
-var allUserMessageSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  subject: import_zod6.z.string(),
-  msg: import_zod6.z.string(),
-  sent_at: import_zod6.z.string(),
-  is_read: import_zod6.z.boolean(),
-  sender_full_name: import_zod6.z.string(),
-  sender_profile_image_url: import_zod6.z.string().nullable()
-});
-var getAllUserMessagesResponseSchema = import_zod6.z.object({
-  messages: import_zod6.z.array(allUserMessageSchema)
-});
-var markMessageAsReadRequest = import_zod6.z.object({
-  params: import_zod6.z.object({
-    id: import_zod6.z.string()
-    // MSG ID
+var allUserMessageSchema = z12.object({
+  id: messageDbSchema.shape.id,
+  subject: messageDbSchema.shape.subject,
+  msg: messageDbSchema.shape.msg,
+  sentAt: serializedDateSchema,
+  isRead: messageDbSchema.shape.isRead,
+  senderFullName: userDbSchema.shape.name,
+  senderProfileImageUrl: userDbSchema.shape.profilePicPath
+});
+var getAllUserMessagesResponseSchema = z12.object({
+  messages: z12.array(allUserMessageSchema)
+});
+var markMessageAsReadRequest = z12.object({
+  params: z12.object({
+    id: messageDbSchema.shape.id
   })
 });
-var messageAsReadSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  is_read: import_zod6.z.boolean()
+var messageAsReadSchema = z12.object({
+  id: messageDbSchema.shape.id,
+  isRead: messageDbSchema.shape.isRead
 });
 var markMessageAsReadResponseSchema = messageAsReadSchema;
-var deleteMessageRequest = import_zod6.z.object({
-  params: import_zod6.z.object({
-    id: import_zod6.z.string()
-    // MSG ID
+var deleteMessageRequest = z12.object({
+  params: z12.object({
+    id: messageDbSchema.shape.id
   })
 });
-var deletedMessageSchema = import_zod6.z.object({
-  id: import_zod6.z.string()
+var deletedMessageSchema = z12.object({
+  id: messageDbSchema.shape.id
+});
+var messageAfterSendResponseSchema = z12.object({
+  id: messageDbSchema.shape.id,
+  senderId: messageDbSchema.shape.senderId,
+  receiverId: messageDbSchema.shape.receiverId,
+  subject: messageDbSchema.shape.subject,
+  msg: messageDbSchema.shape.msg,
+  sentAt: serializedDateSchema,
+  isRead: messageDbSchema.shape.isRead,
+  senderUsername: userDbSchema.shape.username,
+  senderFullName: userDbSchema.shape.name,
+  senderProfileImageUrl: userDbSchema.shape.profilePicPath,
+  senderGender: userDbSchema.shape.gender
 });
 var deleteMessageResponseSchema = deletedMessageSchema;
 
-// src/modules/user/update/update.schemas.ts
-var import_zod7 = require("zod");
-var updateUserRequest = import_zod7.z.object({
-  body: import_zod7.z.object({
-    username: import_zod7.z.string().trim().min(3, "Username must be at least 3 characters").max(15, "Username must be at most 15 characters").regex(/^[a-zA-Z0-9_]+$/, "Username may contain letters, numbers, and underscore only"),
-    fullName: import_zod7.z.string().trim().min(1, "Full name is required").max(20, "Full name is too long").regex(/^[a-zA-Z\s]+$/, "Full name may contain letters and spaces only"),
-    email: import_zod7.z.string().trim().toLowerCase().email("Invalid email format")
-  }).partial()
-});
-var deleteProfilePicRequest = import_zod7.z.object({
-  body: import_zod7.z.object({
-    path: import_zod7.z.string()
-  })
-});
-var userDataSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  username: import_zod7.z.string(),
-  email: import_zod7.z.string().nullable(),
-  name: import_zod7.z.string(),
-  gender: import_zod7.z.string(),
-  created_at: import_zod7.z.string(),
-  profile_image_url: import_zod7.z.string().nullable(),
-  push_token: import_zod7.z.string().nullable(),
-  role: import_zod7.z.string(),
-  is_first_login: import_zod7.z.boolean(),
-  token_version: import_zod7.z.number(),
-  is_verified: import_zod7.z.boolean(),
-  auth_provider: import_zod7.z.string()
-});
-var userDataResponseSchema = import_zod7.z.object({
-  user_data: userDataSchema
-});
-var getAuthenticatedUserByIdResponseSchema = userDataSchema;
-var updateAuthenticatedUserResponseSchema = import_zod7.z.object({
-  message: import_zod7.z.string(),
-  emailChanged: import_zod7.z.boolean(),
-  user: userDataSchema
-});
-var setProfilePicAndUpdateDBResponseSchema = import_zod7.z.object({
-  path: import_zod7.z.string(),
-  url: import_zod7.z.string(),
-  message: import_zod7.z.string()
-});
-
 // src/modules/workout/plan/plan.schemas.ts
-var import_zod8 = require("zod");
-var workoutExerciseSchema = import_zod8.z.object({
-  id: import_zod8.z.number(),
-  sets: import_zod8.z.array(import_zod8.z.number()),
-  order_index: import_zod8.z.number()
-});
-var exerciseInPlanSchema = import_zod8.z.object({
-  id: import_zod8.z.number(),
-  sets: import_zod8.z.array(import_zod8.z.number()),
-  is_active: import_zod8.z.boolean(),
-  targetmuscle: import_zod8.z.string(),
-  specifictargetmuscle: import_zod8.z.string(),
-  exercise: import_zod8.z.string(),
-  workoutsplit: import_zod8.z.string()
-});
-var workoutSplitSchema = import_zod8.z.object({
-  id: import_zod8.z.number(),
-  workout_id: import_zod8.z.number(),
-  name: import_zod8.z.string(),
-  created_at: import_zod8.z.string(),
-  muscle_group: import_zod8.z.string().nullable(),
-  is_active: import_zod8.z.boolean(),
-  exercisetoworkoutsplit: import_zod8.z.array(exerciseInPlanSchema)
-});
-var wholeUserWorkoutPlanSchema = import_zod8.z.object({
-  id: import_zod8.z.number(),
-  name: import_zod8.z.string(),
-  numberofsplits: import_zod8.z.number(),
-  created_at: import_zod8.z.string(),
-  is_deleted: import_zod8.z.boolean(),
-  level: import_zod8.z.string(),
-  user_id: import_zod8.z.string(),
-  trainer_id: import_zod8.z.string(),
-  is_active: import_zod8.z.boolean(),
-  updated_at: import_zod8.z.string(),
-  workoutsplits: import_zod8.z.array(workoutSplitSchema).nullable()
-});
-var workoutSplitsMapItemSchema = import_zod8.z.object({
-  id: import_zod8.z.number(),
-  name: import_zod8.z.string(),
-  sets: import_zod8.z.array(import_zod8.z.number()),
-  order_index: import_zod8.z.number(),
-  targetmuscle: import_zod8.z.string(),
-  specifictargetmuscle: import_zod8.z.string()
-});
-var workoutSplitsMapSchema = import_zod8.z.record(import_zod8.z.string(), import_zod8.z.array(workoutSplitsMapItemSchema));
-var addWorkoutSplitPayloadSchema = import_zod8.z.record(
-  import_zod8.z.string(),
-  import_zod8.z.array(workoutExerciseSchema).min(1, "Each split must include at least one exercise")
-);
-var addWorkoutRequest = import_zod8.z.object({
-  body: import_zod8.z.object({
+import { z as z13 } from "zod/v4";
+var workoutExerciseSchema = z13.object({
+  id: exerciseDbSchema.shape.id,
+  sets: z13.array(workoutSetDbSchema.shape.reps),
+  orderIndex: exerciseToWorkoutSplitDbSchema.shape.orderIndex
+});
+var exerciseInPlanSchema = z13.object({
+  id: exerciseToWorkoutSplitDbSchema.shape.id,
+  sets: z13.array(workoutSetDbSchema.shape.reps),
+  isActive: exerciseToWorkoutSplitDbSchema.shape.isActive,
+  targetMuscle: exerciseDbSchema.shape.targetMuscle,
+  specificTargetMuscle: exerciseDbSchema.shape.specificTargetMuscle,
+  exercise: exerciseDbSchema.shape.name,
+  workoutSplit: workoutSplitDbSchema.shape.name
+});
+var workoutSplitSchema = z13.object({
+  id: workoutSplitDbSchema.shape.id,
+  workoutId: workoutSplitDbSchema.shape.workoutId,
+  name: workoutSplitDbSchema.shape.name,
+  createdAt: serializedDateSchema,
+  muscleGroup: z13.string().nullable(),
+  isActive: workoutSplitDbSchema.shape.isActive,
+  exerciseToWorkoutSplit: z13.array(exerciseInPlanSchema)
+});
+var wholeUserWorkoutPlanSchema = z13.object({
+  id: workoutPlanDbSchema.shape.id,
+  numberOfSplits: z13.number(),
+  createdAt: serializedDateSchema,
+  userId: userDbSchema.shape.id,
+  isActive: workoutPlanDbSchema.shape.isActive,
+  updatedAt: serializedDateSchema,
+  workoutSplits: z13.array(workoutSplitSchema).nullable()
+});
+var workoutSplitsMapItemSchema = z13.object({
+  id: exerciseDbSchema.shape.id,
+  name: exerciseDbSchema.shape.name,
+  sets: z13.array(workoutSetDbSchema.shape.reps),
+  orderIndex: exerciseToWorkoutSplitDbSchema.shape.orderIndex,
+  targetMuscle: exerciseDbSchema.shape.targetMuscle,
+  specificTargetMuscle: exerciseDbSchema.shape.specificTargetMuscle
+});
+var workoutSplitsMapSchema = z13.record(z13.string(), z13.array(workoutSplitsMapItemSchema));
+var addWorkoutSplitPayloadSchema = z13.record(z13.string(), z13.array(workoutExerciseSchema).min(1, "Each split must include at least one exercise"));
+var addWorkoutRequest = z13.object({
+  body: z13.object({
     workoutData: addWorkoutSplitPayloadSchema,
-    workoutName: import_zod8.z.string().optional(),
-    tz: import_zod8.z.string()
+    workoutName: z13.string().optional(),
+    tz: z13.string()
   })
 });
-var addWorkoutResponseSchema = import_zod8.z.object({
-  message: import_zod8.z.string(),
+var addWorkoutResponseSchema = z13.object({
+  message: z13.string(),
   workoutPlan: wholeUserWorkoutPlanSchema,
   workoutPlanForEditWorkout: workoutSplitsMapSchema
 });
-var getWholeWorkoutPlanRequest = import_zod8.z.object({
-  query: import_zod8.z.object({
-    tz: import_zod8.z.string().optional()
+var getWholeWorkoutPlanRequest = z13.object({
+  query: z13.object({
+    tz: z13.string().optional()
   })
 });
-var getWholeUserWorkoutPlanResponseSchema = import_zod8.z.object({
+var getWholeUserWorkoutPlanResponseSchema = z13.object({
   workoutPlan: wholeUserWorkoutPlanSchema.nullable(),
   workoutPlanForEditWorkout: workoutSplitsMapSchema.nullable()
 });
 
 // src/modules/workout/tracking/tracking.schemas.ts
-var import_zod9 = require("zod");
-var finishedExerciseEntry = import_zod9.z.object({
-  exercisetosplit_id: import_zod9.z.number(),
-  weight: import_zod9.z.array(import_zod9.z.number()),
-  reps: import_zod9.z.array(import_zod9.z.number()),
-  notes: import_zod9.z.string().optional().nullable()
-});
-var exerciseMetadataSchema = import_zod9.z.object({
-  targetmuscle: import_zod9.z.string(),
-  specifictargetmuscle: import_zod9.z.string()
-});
-var exerciseTrackingPrMaxSchema = import_zod9.z.object({
-  exercise: import_zod9.z.string(),
-  weight: import_zod9.z.number(),
-  reps: import_zod9.z.number(),
-  workout_time_utc: import_zod9.z.string()
-});
-var exerciseTrackingAnalysisSchema = import_zod9.z.object({
-  unique_days: import_zod9.z.number(),
-  most_frequent_split: import_zod9.z.string().nullable(),
-  most_frequent_split_days: import_zod9.z.number().nullable(),
-  lastWorkoutDate: import_zod9.z.string().nullable(),
-  splitDaysByName: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.number()),
-  prs: import_zod9.z.object({
-    pr_max: exerciseTrackingPrMaxSchema.nullable()
-  })
-});
-var trackingMapItemSchema = import_zod9.z.object({
-  id: import_zod9.z.number(),
-  exercisetosplit_id: import_zod9.z.number(),
-  weight: import_zod9.z.array(import_zod9.z.number()),
-  reps: import_zod9.z.array(import_zod9.z.number()),
-  notes: import_zod9.z.string().nullable(),
-  exercise_id: import_zod9.z.number(),
-  workoutsplit_id: import_zod9.z.number(),
-  splitname: import_zod9.z.string(),
-  exercise: import_zod9.z.string(),
-  workoutdate: import_zod9.z.string(),
-  order_index: import_zod9.z.number(),
-  exercisetoworkoutsplit: import_zod9.z.object({
-    sets: import_zod9.z.array(import_zod9.z.number()),
+import { z as z14 } from "zod/v4";
+var finishedExerciseEntry = z14.object({
+  exerciseToSplitId: exerciseToWorkoutSplitDbSchema.shape.id,
+  weight: z14.array(trackingSetDbSchema.shape.weight),
+  reps: z14.array(trackingSetDbSchema.shape.reps),
+  notes: exerciseTrackingDbSchema.shape.notes.optional()
+});
+var exerciseMetadataSchema = z14.object({
+  targetMuscle: exerciseDbSchema.shape.targetMuscle,
+  specificTargetMuscle: exerciseDbSchema.shape.specificTargetMuscle
+});
+var exerciseTrackingPrMaxSchema = z14.object({
+  exercise: exerciseDbSchema.shape.name,
+  weight: trackingSetDbSchema.shape.weight,
+  reps: trackingSetDbSchema.shape.reps,
+  workoutTimeUtc: serializedDateSchema
+});
+var exerciseTrackingAnalysisSchema = z14.object({
+  uniqueDays: z14.number(),
+  mostFrequentSplit: z14.string().nullable(),
+  mostFrequentSplitDays: z14.number().nullable(),
+  lastWorkoutDate: z14.string().nullable(),
+  splitDaysByName: z14.record(z14.string(), z14.number()),
+  prs: z14.object({
+    prMax: exerciseTrackingPrMaxSchema.nullable()
+  })
+});
+var trackingMapItemSchema = z14.object({
+  id: exerciseTrackingDbSchema.shape.id,
+  exerciseToSplitId: exerciseToWorkoutSplitDbSchema.shape.id,
+  weight: z14.array(trackingSetDbSchema.shape.weight),
+  reps: z14.array(trackingSetDbSchema.shape.reps),
+  notes: exerciseTrackingDbSchema.shape.notes,
+  exerciseId: exerciseDbSchema.shape.id,
+  workoutSplitId: workoutSplitDbSchema.shape.id,
+  splitName: workoutSplitDbSchema.shape.name,
+  exercise: exerciseDbSchema.shape.name,
+  workoutDate: serializedDateSchema,
+  orderIndex: exerciseToWorkoutSplitDbSchema.shape.orderIndex,
+  exerciseToWorkoutSplit: z14.object({
+    sets: z14.array(workoutSetDbSchema.shape.reps),
     exercises: exerciseMetadataSchema
   })
 });
-var trackingByDateItemSchema = trackingMapItemSchema.omit({ workoutdate: true });
-var trackingBySplitNameItemSchema = trackingMapItemSchema.omit({ splitname: true });
-var exerciseTrackingAndStatsSchema = import_zod9.z.object({
+var trackingByDateItemSchema = trackingMapItemSchema.omit({
+  workoutDate: true
+});
+var trackingBySplitNameItemSchema = trackingMapItemSchema.omit({
+  splitName: true
+});
+var exerciseTrackingAndStatsSchema = z14.object({
   exerciseTrackingAnalysis: exerciseTrackingAnalysisSchema,
-  exerciseTrackingMaps: import_zod9.z.object({
-    byDate: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(trackingByDateItemSchema)),
-    byETSId: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(trackingMapItemSchema)),
-    bySplitName: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(trackingBySplitNameItemSchema))
+  exerciseTrackingMaps: z14.object({
+    byDate: z14.record(z14.string(), z14.array(trackingByDateItemSchema)),
+    byExerciseToSplitId: z14.record(z14.string(), z14.array(trackingMapItemSchema)),
+    bySplitName: z14.record(z14.string(), z14.array(trackingBySplitNameItemSchema))
   })
 });
-var finishWorkoutRequest = import_zod9.z.object({
-  body: import_zod9.z.object({
-    workout: import_zod9.z.array(finishedExerciseEntry),
-    tz: import_zod9.z.string().optional(),
-    workout_start_utc: import_zod9.z.string().datetime("workout_start_utc must be a valid ISO datetime"),
-    workout_end_utc: import_zod9.z.string().datetime("workout_end_utc must be a valid ISO datetime").optional().nullable()
+var finishWorkoutRequest = z14.object({
+  body: z14.object({
+    workout: z14.array(finishedExerciseEntry),
+    tz: z14.string().optional(),
+    workoutStartUtc: z14.string().datetime("workoutStartUtc must be a valid ISO datetime"),
+    workoutEndUtc: z14.string().datetime("workoutEndUtc must be a valid ISO datetime").optional().nullable()
   })
 });
 var finishUserWorkoutResponseSchema = exerciseTrackingAndStatsSchema;
-var getExerciseTrackingRequest = import_zod9.z.object({
-  query: import_zod9.z.object({
-    tz: import_zod9.z.string().optional()
+var getExerciseTrackingRequest = z14.object({
+  query: z14.object({
+    tz: z14.string().optional()
   })
 });
 var getExerciseTrackingResponseSchema = exerciseTrackingAndStatsSchema;
 
 // src/modules/bootstrap/bootstrap.schemas.ts
-var bootstrapRequest = import_zod10.z.object({
-  query: import_zod10.z.object({
-    tz: import_zod10.z.string().optional()
+var bootstrapRequest = z15.object({
+  query: z15.object({
+    tz: z15.string().optional()
   })
 });
-var bootstrapResponseSchema = import_zod10.z.object({
+var bootstrapResponseSchema = z15.object({
   user: userDataSchema,
   workout: getWholeUserWorkoutPlanResponseSchema,
   tracking: exerciseTrackingAndStatsSchema,
@@ -472,137 +1916,225 @@ var bootstrapResponseSchema = import_zod10.z.object({
 });
 
 // src/modules/exercises/exercises.schemas.ts
-var import_zod11 = require("zod");
-var getAllExercisesResponseSchema = import_zod11.z.record(
-  import_zod11.z.string(),
-  import_zod11.z.array(
-    import_zod11.z.object({
-      id: import_zod11.z.number(),
-      name: import_zod11.z.string(),
-      specificTargetMuscle: import_zod11.z.string()
-    })
-  )
-);
+import { z as z16 } from "zod/v4";
+var getAllExercisesExerciseSchema = z16.object({
+  id: exerciseDbSchema.shape.id,
+  name: exerciseDbSchema.shape.name,
+  specificTargetMuscle: exerciseDbSchema.shape.specificTargetMuscle
+});
+var getAllExercisesResponseSchema = z16.record(z16.string(), z16.array(getAllExercisesExerciseSchema));
+var queryGetExerciseMapByMuscleRowSchema = z16.object({
+  result: z16.object({
+    map: getAllExercisesResponseSchema.nullable()
+  }).nullable()
+});
+
+// src/modules/oauth/apple/apple.dtos.ts
+import { z as z17 } from "zod/v4";
+var appleTokenVerificationResultSchema = z17.object({
+  appleSub: z17.string(),
+  email: userDbSchema.shape.email.nullable(),
+  emailVerified: z17.boolean(),
+  fullName: userDbSchema.shape.name
+});
 
 // src/modules/oauth/apple/apple.schemas.ts
-var import_zod12 = require("zod");
-var appleNameInput = import_zod12.z.object({
-  givenName: import_zod12.z.string().nullable(),
-  familyName: import_zod12.z.string().nullable()
-});
-var appleOAuthRequest = import_zod12.z.object({
-  body: import_zod12.z.object({
-    idToken: import_zod12.z.string({
-      required_error: "Missing or invalid Apple identityToken",
-      invalid_type_error: "Missing or invalid Apple identityToken"
-    }),
-    rawNonce: import_zod12.z.string(),
+import { z as z18 } from "zod/v4";
+var appleNameInput = z18.object({
+  givenName: z18.string().nullable(),
+  familyName: z18.string().nullable()
+});
+var appleOAuthRequest = z18.object({
+  body: z18.object({
+    idToken: z18.string({
+      error: "Missing or invalid Apple identityToken"
+    }),
+    rawNonce: z18.string(),
     name: appleNameInput.optional(),
-    email: import_zod12.z.string().email().nullable()
+    email: userDbSchema.shape.email.email().nullable()
   })
 });
 
+// src/modules/oauth/google/google.dtos.ts
+import { z as z19 } from "zod/v4";
+var googleTokenVerificationResultSchema = z19.object({
+  googleSub: z19.string(),
+  email: userDbSchema.shape.email.nullable(),
+  emailVerified: z19.boolean(),
+  fullName: userDbSchema.shape.name
+});
+
 // src/modules/oauth/google/google.schemas.ts
-var import_zod13 = require("zod");
-var googleOAuthRequest = import_zod13.z.object({
-  body: import_zod13.z.object({
-    idToken: import_zod13.z.string().optional()
+import { z as z20 } from "zod/v4";
+var googleOAuthRequest = z20.object({
+  body: z20.object({
+    idToken: z20.string().optional()
   })
 });
 
 // src/modules/oauth/oauth.schemas.ts
-var import_zod14 = require("zod");
-var oAuthLoginResponseSchema = import_zod14.z.object({
-  message: import_zod14.z.string(),
-  user: import_zod14.z.string(),
-  accessToken: import_zod14.z.string(),
-  refreshToken: import_zod14.z.string(),
-  missingFields: import_zod14.z.array(import_zod14.z.string()).nullable()
+import { z as z21 } from "zod/v4";
+var oAuthLoginResponseSchema = z21.object({
+  message: z21.string(),
+  user: userDbSchema.shape.id,
+  accessToken: z21.string(),
+  refreshToken: z21.string(),
+  missingFields: z21.array(z21.string()).nullable()
 });
 var proceedLoginResponseSchema = loginResponseSchema;
 
 // src/modules/user/create/create.schemas.ts
-var import_zod15 = require("zod");
-var createUserRequest = import_zod15.z.object({
-  body: import_zod15.z.object({
-    username: import_zod15.z.string().trim().min(3, "Username must be at least 3 characters").max(15, "Username must be at most 15 characters").regex(/^[a-zA-Z0-9_]+$/, "Username may contain letters, numbers, and underscore only"),
-    fullName: import_zod15.z.preprocess(
+import { z as z22 } from "zod/v4";
+var usernameSchema = userDbSchema.shape.username.trim().min(3, "Username must be at least 3 characters").max(15, "Username must be at most 15 characters").regex(/^[a-zA-Z0-9_]+$/, "Username may contain letters, numbers, and underscore only");
+var fullNameSchema = userDbSchema.shape.name.trim().max(20, "Full name is too long").regex(/^[a-zA-Z\s]+$/, "Full name may contain letters and spaces only");
+var createUserRequest = z22.object({
+  body: z22.object({
+    username: usernameSchema,
+    fullName: z22.preprocess(
       // Map "", null, undefined -> "User"
       (val) => {
         if (val == null) return "User";
         if (typeof val === "string" && val.trim() === "") return "User";
         return val;
       },
-      import_zod15.z.string().trim().max(20, "Full name is too long").regex(/^[a-zA-Z\s]+$/, "Full name may contain letters and spaces only")
+      fullNameSchema
     ),
-    email: import_zod15.z.string().trim().toLowerCase().email("Invalid email format"),
-    password: import_zod15.z.string().min(8, "Password must be at least 8 characters long"),
-    gender: import_zod15.z.preprocess(
-      (val) => val === "" || val == null ? "Unknown" : val,
-      import_zod15.z.enum(["Male", "Female", "Other", "Unknown"])
-    )
-  })
-});
-var createUserUserSchema = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  username: import_zod15.z.string(),
-  name: import_zod15.z.string(),
-  email: import_zod15.z.string().nullable(),
-  gender: import_zod15.z.string(),
-  role: import_zod15.z.string(),
-  created_at: import_zod15.z.string()
-});
-var createUserResponseSchema = import_zod15.z.object({
-  message: import_zod15.z.string(),
+    email: userDbSchema.shape.email.trim().toLowerCase().email("Invalid email format"),
+    password: z22.string().min(8, "Password must be at least 8 characters long"),
+    gender: z22.preprocess((val) => val === "" || val == null ? "Unknown" : val, z22.enum([
+      "Male",
+      "Female",
+      "Other",
+      "Unknown"
+    ]))
+  })
+});
+var createUserUserSchema = z22.object({
+  id: userDbSchema.shape.id,
+  username: userDbSchema.shape.username,
+  name: userDbSchema.shape.name,
+  email: userDbSchema.shape.email,
+  gender: userDbSchema.shape.gender,
+  role: userDbSchema.shape.role,
+  createdAt: serializedDateSchema
+});
+var createUserResponseSchema = z22.object({
+  message: z22.string(),
   user: createUserUserSchema
 });
 
 // src/modules/user/push-tokens/push-tokens.schemas.ts
-var import_zod16 = require("zod");
-var saveUserPushTokenRequest = import_zod16.z.object({
-  body: import_zod16.z.object({
-    token: import_zod16.z.string()
+import { z as z23 } from "zod/v4";
+var saveUserPushTokenRequest = z23.object({
+  body: z23.object({
+    token: userDbSchema.shape.pushToken.unwrap()
+  })
+});
+
+// src/modules/user/update/update.dtos.ts
+import { z as z24 } from "zod/v4";
+var changeEmailTokenPayloadSchema = z24.object({
+  jti: z24.string(),
+  sub: z24.string(),
+  newEmail: z24.string(),
+  exp: z24.number(),
+  iss: z24.string(),
+  typ: z24.string()
+});
+
+// src/modules/video-analysis/video-analysis.dtos.ts
+import { z as z25 } from "zod/v4";
+var enqueueAanalyzeVideoParamsSchema = z25.object({
+  fileKey: z25.string(),
+  exercise: z25.string(),
+  userId: userDbSchema.shape.id,
+  requestId: z25.string(),
+  sentryTrace: z25.string().optional(),
+  baggage: z25.string().optional()
+});
+var analyzeVideoPayloadSchema = enqueueAanalyzeVideoParamsSchema.extend({
+  expiresAt: z25.number()
+});
+var squatRepetitionSchema = z25.object({
+  depth: z25.object({
+    value: z25.number(),
+    status: z25.string(),
+    confidence: z25.number()
+  }),
+  backLean: z25.object({
+    value: z25.number(),
+    excessive: z25.boolean(),
+    confidence: z25.number()
+  }),
+  audit: z25.object({
+    framesAnalyzed: z25.number(),
+    validFrames: z25.number(),
+    cameraAngle: z25.string(),
+    rawBottomAngle: z25.number(),
+    samplingRate: z25.string()
   })
 });
+var analyzeVideoResultPayloadSchema = /* @__PURE__ */ __name((resultSchema) => z25.intersection(z25.object({
+  jobId: z25.string(),
+  userId: userDbSchema.shape.id,
+  exercise: z25.string(),
+  requestId: z25.string().optional()
+}), z25.discriminatedUnion("status", [
+  z25.object({
+    status: z25.literal("completed"),
+    result: z25.array(resultSchema),
+    error: z25.null()
+  }),
+  z25.object({
+    status: z25.literal("failed"),
+    result: z25.null(),
+    error: z25.string()
+  })
+])), "analyzeVideoResultPayloadSchema");
 
 // src/modules/video-analysis/video-analysis.schemas.ts
-var import_zod17 = require("zod");
-var getPresignedUrlS3Request = import_zod17.z.object({
-  body: import_zod17.z.object({
-    exercise: import_zod17.z.string(),
-    fileType: import_zod17.z.string(),
-    jobId: import_zod17.z.string()
+import { z as z26 } from "zod/v4";
+var getPresignedUrlS3Request = z26.object({
+  body: z26.object({
+    exercise: exerciseDbSchema.shape.name,
+    fileType: z26.string(),
+    jobId: z26.string()
   })
 });
-var getPresignedUrlFromS3ResponseSchema = import_zod17.z.object({
-  uploadUrl: import_zod17.z.string(),
-  fileKey: import_zod17.z.string(),
-  requestId: import_zod17.z.string()
+var getPresignedUrlFromS3ResponseSchema = z26.object({
+  uploadUrl: z26.string(),
+  fileKey: z26.string(),
+  requestId: z26.string()
 });
 
 // src/modules/web-sockets/web-sockets.schemas.ts
-var import_zod18 = require("zod");
-var generateTicketRequest = import_zod18.z.object({
-  body: import_zod18.z.object({
-    username: import_zod18.z.string()
+import { z as z27 } from "zod/v4";
+var generateTicketRequest = z27.object({
+  body: z27.object({
+    username: userDbSchema.shape.username
   })
 });
-var generateTicketResponseSchema = import_zod18.z.object({
-  ticket: import_zod18.z.string()
+var generateTicketResponseSchema = z27.object({
+  ticket: z27.string()
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
+  accessTokenPayloadSchema,
   addAerobicsRequest,
   addWorkoutRequest,
   addWorkoutResponseSchema,
   adherenceExerciseStatsSchema,
+  aerobicTrackingDbSchema,
   aerobicsDailyRecordSchema,
   aerobicsWeeklyRecordSchema,
   allUserMessageSchema,
+  analyzeVideoPayloadSchema,
+  analyzeVideoResultPayloadSchema,
   appleOAuthRequest,
+  appleTokenVerificationResultSchema,
   bootstrapRequest,
   bootstrapResponseSchema,
   changeEmailAndVerifyRequest,
+  changeEmailTokenPayloadSchema,
   checkUserVerifyRequest,
   createUserRequest,
   createUserResponseSchema,
@@ -611,16 +2143,25 @@ var generateTicketResponseSchema = import_zod18.z.object({
   deleteMessageResponseSchema,
   deleteProfilePicRequest,
   deletedMessageSchema,
+  emailVerifyPayloadSchema,
+  enqueueAanalyzeVideoParamsSchema,
+  exerciseDbSchema,
   exerciseInPlanSchema,
   exerciseMetadataSchema,
+  exerciseToWorkoutSplitDbSchema,
+  exerciseToWorkoutSplitExpandedViewDbSchema,
   exerciseTrackingAnalysisSchema,
   exerciseTrackingAndStatsSchema,
+  exerciseTrackingDbSchema,
+  exerciseTrackingExpandedViewDbSchema,
   exerciseTrackingPrMaxSchema,
   finishUserWorkoutResponseSchema,
   finishWorkoutRequest,
+  forgotPasswordPayloadSchema,
   generateTicketRequest,
   generateTicketResponseSchema,
   getAerobicsRequest,
+  getAllExercisesExerciseSchema,
   getAllExercisesResponseSchema,
   getAllMessagesRequest,
   getAllUserMessagesResponseSchema,
@@ -633,34 +2174,56 @@ var generateTicketResponseSchema = import_zod18.z.object({
   getWholeUserWorkoutPlanResponseSchema,
   getWholeWorkoutPlanRequest,
   googleOAuthRequest,
+  googleTokenVerificationResultSchema,
   loginRequest,
   loginResponseSchema,
   logoutResponseSchema,
   markMessageAsReadRequest,
   markMessageAsReadResponseSchema,
+  messageAfterSendResponseSchema,
   messageAsReadSchema,
+  messageDbSchema,
   oAuthLoginResponseSchema,
+  oauthAccountDbSchema,
   proceedLoginResponseSchema,
+  prsViewDbSchema,
+  queryGetExerciseMapByMuscleRowSchema,
   refreshTokenResponseSchema,
   resetPasswordRequest,
   resetPasswordResponseSchema,
   saveUserPushTokenRequest,
   sendChangePassEmailRequest,
   sendVerificationMailRequest,
+  serializedDateSchema,
   setProfilePicAndUpdateDBResponseSchema,
+  squatRepetitionSchema,
+  timezoneSchema,
+  tokenVersionResultSchema,
   trackingByDateItemSchema,
   trackingBySplitNameItemSchema,
   trackingMapItemSchema,
+  trackingSetDbSchema,
   updateAuthenticatedUserResponseSchema,
   updateUserRequest,
   userAerobicsResponseSchema,
+  userAfterBumpSchema,
+  userByIndetifierSchema,
   userDataResponseSchema,
   userDataSchema,
+  userDbSchema,
+  userInsertDbSchema,
+  userReminderSettingDbSchema,
+  userSplitInformationDbSchema,
+  userUpdateDbSchema,
   verifyAccountRequest,
   weeklyDataSchema,
   wholeUserWorkoutPlanSchema,
+  workoutPlanDbSchema,
   workoutRmRecordSchema,
+  workoutSetDbSchema,
+  workoutSplitDbSchema,
   workoutSplitSchema,
   workoutSplitsMapItemSchema,
-  workoutSplitsMapSchema
-});
+  workoutSplitsMapSchema,
+  workoutSummaryDbSchema
+};