@compfest-18/oppenheimer-schema 0.0.5-develop.c0e6c23 → 0.0.6-develop.5850f63

package/dist/index.mjs

@@ -47,6 +47,11 @@ var submissionStatusEnum = pgEnum("submission_status", [
   "REJECTED",
   "ACCEPTED"
 ]);
+var joinRequestStatusEnum = pgEnum("join_request_status", [
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED"
+]);
 var knowEventSourceEnum = pgEnum("know_event_source", [
   "INSTAGRAM",
   "WEBSITE",
@@ -397,11 +402,11 @@ var feedbacksRelations = relations11(feedbacks, ({ many }) => ({
 
 // programs/member.schema.ts
 import { relations as relations16 } from "drizzle-orm";
-import { boolean as boolean3, index as index15, pgTable as pgTable17, text as text17, timestamp as timestamp17 } from "drizzle-orm/pg-core";
+import { boolean as boolean4, index as index15, pgTable as pgTable17, text as text17, timestamp as timestamp17 } from "drizzle-orm/pg-core";
 
 // programs/team.schema.ts
 import { relations as relations15 } from "drizzle-orm";
-import { index as index14, pgTable as pgTable16, text as text16, timestamp as timestamp16 } from "drizzle-orm/pg-core";
+import { boolean as boolean3, index as index14, pgTable as pgTable16, text as text16, timestamp as timestamp16 } from "drizzle-orm/pg-core";
 
 // programs/program.schema.ts
 import { relations as relations14 } from "drizzle-orm";
@@ -518,6 +523,7 @@ var teams = pgTable16(
     code: text16("code").notNull().unique(),
     status: teamStatusEnum("status").notNull().default("WAITING_FOR_VERIFICATION"),
     notes: text16("notes"),
+    isPublic: boolean3("is_public").notNull().default(false),
     deletedAt: timestamp16("deleted_at"),
     createdAt: timestamp16("created_at").notNull().defaultNow(),
     updatedAt: timestamp16("updated_at").notNull().defaultNow()
@@ -543,7 +549,7 @@ var members = pgTable17(
     id: text17("id").primaryKey(),
     userId: text17("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
     teamId: text17("team_id").notNull().references(() => teams.id, { onDelete: "cascade" }),
-    isLeader: boolean3("is_leader").notNull().default(false),
+    isLeader: boolean4("is_leader").notNull().default(false),
     deletedAt: timestamp17("deleted_at"),
     createdAt: timestamp17("created_at").notNull().defaultNow(),
     updatedAt: timestamp17("updated_at").notNull().defaultNow()
@@ -564,27 +570,94 @@ var membersRelations = relations16(members, ({ one }) => ({
   })
 }));
 
-// tasks/program-task.schema.ts
+// programs/team-join-request.schema.ts
 import { relations as relations17 } from "drizzle-orm";
 import { index as index16, pgTable as pgTable18, text as text18, timestamp as timestamp18 } from "drizzle-orm/pg-core";
-var programTasks = pgTable18(
-  "program_tasks",
+var teamJoinRequests = pgTable18(
+  "team_join_requests",
   {
     id: text18("id").primaryKey(),
-    programId: text18("program_id").notNull().references(() => programs.id, { onDelete: "cascade" }),
-    title: text18("title").notNull(),
-    deadline: timestamp18("deadline"),
-    description: text18("description"),
-    guideBookUrl: text18("guide_book_url"),
-    type: programTaskTypeEnum("type").notNull(),
-    acceptedFileTypes: fileTypeEnum("accepted_file_types").array(),
+    teamId: text18("team_id").notNull().references(() => teams.id, { onDelete: "cascade" }),
+    userId: text18("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    status: joinRequestStatusEnum("status").notNull().default("PENDING"),
     deletedAt: timestamp18("deleted_at"),
     createdAt: timestamp18("created_at").notNull().defaultNow(),
     updatedAt: timestamp18("updated_at").notNull().defaultNow()
   },
-  (table) => [index16("program_tasks_program_id_idx").on(table.programId)]
+  (table) => [
+    index16("team_join_requests_team_id_idx").on(table.teamId),
+    index16("team_join_requests_user_id_idx").on(table.userId)
+  ]
+);
+var teamJoinRequestsRelations = relations17(teamJoinRequests, ({ one }) => ({
+  team: one(teams, {
+    fields: [teamJoinRequests.teamId],
+    references: [teams.id]
+  }),
+  user: one(users, {
+    fields: [teamJoinRequests.userId],
+    references: [users.id]
+  })
+}));
+
+// tasks/competition-payment-proof.schema.ts
+import { relations as relations18 } from "drizzle-orm";
+import { index as index17, pgTable as pgTable19, text as text19, timestamp as timestamp19 } from "drizzle-orm/pg-core";
+var competitionPaymentProofs = pgTable19(
+  "competition_payment_proofs",
+  {
+    id: text19("id").primaryKey(),
+    programId: text19("program_id").notNull().references(() => programs.id, { onDelete: "cascade" }),
+    teamId: text19("team_id").references(() => teams.id, { onDelete: "cascade" }),
+    userId: text19("user_id").references(() => users.id, { onDelete: "cascade" }),
+    fileUrl: text19("file_url").notNull(),
+    fileName: text19("file_name").notNull(),
+    status: submissionStatusEnum("status").notNull().default("PENDING"),
+    createdAt: timestamp19("created_at").notNull().defaultNow(),
+    updatedAt: timestamp19("updated_at").notNull().defaultNow()
+  },
+  (table) => [
+    index17("competition_payment_proofs_program_id_idx").on(table.programId),
+    index17("competition_payment_proofs_team_id_idx").on(table.teamId),
+    index17("competition_payment_proofs_user_id_idx").on(table.userId)
+  ]
+);
+var competitionPaymentProofsRelations = relations18(competitionPaymentProofs, ({ one }) => ({
+  program: one(programs, {
+    fields: [competitionPaymentProofs.programId],
+    references: [programs.id]
+  }),
+  team: one(teams, {
+    fields: [competitionPaymentProofs.teamId],
+    references: [teams.id]
+  }),
+  user: one(users, {
+    fields: [competitionPaymentProofs.userId],
+    references: [users.id]
+  })
+}));
+
+// tasks/program-task.schema.ts
+import { relations as relations19 } from "drizzle-orm";
+import { index as index18, pgTable as pgTable20, text as text20, timestamp as timestamp20 } from "drizzle-orm/pg-core";
+var programTasks = pgTable20(
+  "program_tasks",
+  {
+    id: text20("id").primaryKey(),
+    programId: text20("program_id").notNull().references(() => programs.id, { onDelete: "cascade" }),
+    title: text20("title").notNull(),
+    deadline: timestamp20("deadline"),
+    description: text20("description"),
+    guideBookUrl: text20("guide_book_url"),
+    type: programTaskTypeEnum("type").notNull(),
+    acceptedFileTypes: fileTypeEnum("accepted_file_types").array(),
+    deletedAt: timestamp20("deleted_at"),
+    createdAt: timestamp20("created_at").notNull().defaultNow(),
+    updatedAt: timestamp20("updated_at").notNull().defaultNow()
+  },
+  (table) => [index18("program_tasks_program_id_idx").on(table.programId)]
 );
-var programTasksRelations = relations17(programTasks, ({ one }) => ({
+var programTasksRelations = relations19(programTasks, ({ one }) => ({
   program: one(programs, {
     fields: [programTasks.programId],
     references: [programs.id]
@@ -592,22 +665,22 @@ var programTasksRelations = relations17(programTasks, ({ one }) => ({
 }));
 
 // tasks/program-task-extra-description.schema.ts
-import { relations as relations18 } from "drizzle-orm";
-import { boolean as boolean4, index as index17, pgTable as pgTable19, text as text19, timestamp as timestamp19 } from "drizzle-orm/pg-core";
-var programTaskExtraDescriptions = pgTable19(
+import { relations as relations20 } from "drizzle-orm";
+import { boolean as boolean5, index as index19, pgTable as pgTable21, text as text21, timestamp as timestamp21 } from "drizzle-orm/pg-core";
+var programTaskExtraDescriptions = pgTable21(
   "program_task_extra_descriptions",
   {
-    id: text19("id").primaryKey(),
-    taskId: text19("task_id").notNull().references(() => programTasks.id, { onDelete: "cascade" }),
-    description: text19("description").notNull(),
-    forProgram: boolean4("for_program").notNull().default(true),
-    deletedAt: timestamp19("deleted_at"),
-    createdAt: timestamp19("created_at").notNull().defaultNow(),
-    updatedAt: timestamp19("updated_at").notNull().defaultNow()
+    id: text21("id").primaryKey(),
+    taskId: text21("task_id").notNull().references(() => programTasks.id, { onDelete: "cascade" }),
+    description: text21("description").notNull(),
+    forProgram: boolean5("for_program").notNull().default(true),
+    deletedAt: timestamp21("deleted_at"),
+    createdAt: timestamp21("created_at").notNull().defaultNow(),
+    updatedAt: timestamp21("updated_at").notNull().defaultNow()
   },
-  (table) => [index17("program_task_extra_descriptions_task_id_idx").on(table.taskId)]
+  (table) => [index19("program_task_extra_descriptions_task_id_idx").on(table.taskId)]
 );
-var programTaskExtraDescriptionsRelations = relations18(
+var programTaskExtraDescriptionsRelations = relations20(
   programTaskExtraDescriptions,
   ({ one }) => ({
     task: one(programTasks, {
@@ -618,51 +691,51 @@ var programTaskExtraDescriptionsRelations = relations18(
 );
 
 // tasks/program-task-submission.schema.ts
-import { relations as relations19 } from "drizzle-orm";
-import { index as index18, pgEnum as pgEnum2, pgTable as pgTable20, text as text20, timestamp as timestamp20 } from "drizzle-orm/pg-core";
+import { relations as relations21 } from "drizzle-orm";
+import { index as index20, pgEnum as pgEnum2, pgTable as pgTable22, text as text22, timestamp as timestamp22 } from "drizzle-orm/pg-core";
 var submissionStatusEnumLocal = pgEnum2("submission_status", [
   "PENDING",
   "REJECTED",
   "ACCEPTED"
 ]);
-var programTaskSubmissions = pgTable20(
+var programTaskSubmissions = pgTable22(
   "programTaskSubmissions",
   {
-    id: text20("id").primaryKey(),
-    taskId: text20("taskId").references(() => programTasks.id, {
+    id: text22("id").primaryKey(),
+    taskId: text22("taskId").references(() => programTasks.id, {
       onDelete: "cascade"
     }),
-    teamId: text20("teamId").references(() => teams.id, {
+    teamId: text22("teamId").references(() => teams.id, {
       onDelete: "cascade"
     }),
-    userId: text20("userId").references(() => users.id, {
+    userId: text22("userId").references(() => users.id, {
       onDelete: "cascade"
     }),
-    fileUrl: text20("fileUrl"),
-    fileName: text20("fileName"),
+    fileUrl: text22("fileUrl"),
+    fileName: text22("fileName"),
     status: submissionStatusEnumLocal("status").notNull().default("PENDING"),
-    feedback: text20("feedback"),
+    feedback: text22("feedback"),
     submissionForProgram: programCodeEnum("submissionForProgram"),
-    createdAt: timestamp20("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp20("updatedAt").notNull().defaultNow()
+    createdAt: timestamp22("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp22("updatedAt").notNull().defaultNow()
   },
   (table) => [
-    index18("program_task_submissions_task_id_idx").on(table.taskId),
-    index18("program_task_submissions_team_id_idx").on(table.teamId),
-    index18("program_task_submissions_user_id_idx").on(table.userId),
-    index18("program_task_submissions_task_team_program_idx").on(
+    index20("program_task_submissions_task_id_idx").on(table.taskId),
+    index20("program_task_submissions_team_id_idx").on(table.teamId),
+    index20("program_task_submissions_user_id_idx").on(table.userId),
+    index20("program_task_submissions_task_team_program_idx").on(
       table.taskId,
       table.teamId,
       table.submissionForProgram
     ),
-    index18("program_task_submissions_task_user_program_idx").on(
+    index20("program_task_submissions_task_user_program_idx").on(
       table.taskId,
       table.userId,
       table.submissionForProgram
     )
   ]
 );
-var programTaskSubmissionsRelations = relations19(programTaskSubmissions, ({ one }) => ({
+var programTaskSubmissionsRelations = relations21(programTaskSubmissions, ({ one }) => ({
   task: one(programTasks, {
     fields: [programTaskSubmissions.taskId],
     references: [programTasks.id]
@@ -678,54 +751,54 @@ var programTaskSubmissionsRelations = relations19(programTaskSubmissions, ({ one
 }));
 
 // tasks/xcelerate-workshop-task.schema.ts
-import { index as index19, integer as integer2, pgTable as pgTable21, text as text21, timestamp as timestamp21 } from "drizzle-orm/pg-core";
-var xcelerateWorkshopTasks = pgTable21(
+import { index as index21, integer as integer2, pgTable as pgTable23, text as text23, timestamp as timestamp23 } from "drizzle-orm/pg-core";
+var xcelerateWorkshopTasks = pgTable23(
   "xcelerateWorkshopTasks",
   {
-    id: text21("id").primaryKey(),
-    title: text21("title").notNull(),
-    description: text21("description"),
-    deadline: timestamp21("deadline"),
+    id: text23("id").primaryKey(),
+    title: text23("title").notNull(),
+    description: text23("description"),
+    deadline: timestamp23("deadline"),
     batch: integer2("batch"),
-    taskUrl: text21("taskUrl"),
-    createdAt: timestamp21("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp21("updatedAt").notNull().defaultNow()
+    taskUrl: text23("taskUrl"),
+    createdAt: timestamp23("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp23("updatedAt").notNull().defaultNow()
   },
   (table) => [
-    index19("xcelerate_workshop_tasks_batch_idx").on(table.batch),
-    index19("xcelerate_workshop_tasks_deadline_idx").on(table.deadline)
+    index21("xcelerate_workshop_tasks_batch_idx").on(table.batch),
+    index21("xcelerate_workshop_tasks_deadline_idx").on(table.deadline)
   ]
 );
 
 // tasks/xcelerate-workshop-task-submission.schema.ts
-import { relations as relations20 } from "drizzle-orm";
-import { index as index20, pgTable as pgTable22, text as text22, timestamp as timestamp22, uniqueIndex } from "drizzle-orm/pg-core";
-var xcelerateWorkshopTaskSubmissions = pgTable22(
+import { relations as relations22 } from "drizzle-orm";
+import { index as index22, pgTable as pgTable24, text as text24, timestamp as timestamp24, uniqueIndex } from "drizzle-orm/pg-core";
+var xcelerateWorkshopTaskSubmissions = pgTable24(
   "xcelerateWorkshopTaskSubmissions",
   {
-    id: text22("id").primaryKey(),
-    taskId: text22("taskId").references(() => xcelerateWorkshopTasks.id, {
+    id: text24("id").primaryKey(),
+    taskId: text24("taskId").references(() => xcelerateWorkshopTasks.id, {
       onDelete: "cascade"
     }),
-    userId: text22("userId").references(() => users.id, {
+    userId: text24("userId").references(() => users.id, {
       onDelete: "cascade"
     }),
-    fileUrl: text22("fileUrl"),
+    fileUrl: text24("fileUrl"),
     status: submissionStatusEnum("status").notNull().default("PENDING"),
-    feedback: text22("feedback"),
-    createdAt: timestamp22("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp22("updatedAt").notNull().defaultNow()
+    feedback: text24("feedback"),
+    createdAt: timestamp24("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp24("updatedAt").notNull().defaultNow()
   },
   (table) => [
-    index20("xcelerate_workshop_task_submissions_task_id_idx").on(table.taskId),
-    index20("xcelerate_workshop_task_submissions_user_id_idx").on(table.userId),
+    index22("xcelerate_workshop_task_submissions_task_id_idx").on(table.taskId),
+    index22("xcelerate_workshop_task_submissions_user_id_idx").on(table.userId),
     uniqueIndex("xcelerate_workshop_task_submissions_task_user_idx").on(
       table.taskId,
       table.userId
     )
   ]
 );
-var xcelerateWorkshopTaskSubmissionsRelations = relations20(
+var xcelerateWorkshopTaskSubmissionsRelations = relations22(
   xcelerateWorkshopTaskSubmissions,
   ({ one }) => ({
     task: one(xcelerateWorkshopTasks, {
@@ -740,22 +813,35 @@ var xcelerateWorkshopTaskSubmissionsRelations = relations20(
 );
 
 // announcements/announcement.schema.ts
-import { relations as relations21 } from "drizzle-orm";
-import { index as index21, pgTable as pgTable23, text as text23, timestamp as timestamp23 } from "drizzle-orm/pg-core";
-var announcements = pgTable23(
+import { relations as relations23 } from "drizzle-orm";
+import { boolean as boolean6, index as index23, pgTable as pgTable25, text as text25, timestamp as timestamp25 } from "drizzle-orm/pg-core";
+var announcements = pgTable25(
   "announcements",
   {
-    id: text23("id").primaryKey(),
-    programId: text23("program_id").notNull().references(() => programs.id, { onDelete: "cascade" }),
-    title: text23("title").notNull(),
-    description: text23("description"),
-    deletedAt: timestamp23("deleted_at"),
-    createdAt: timestamp23("created_at").notNull().defaultNow(),
-    updatedAt: timestamp23("updated_at").notNull().defaultNow()
+    id: text25("id").primaryKey(),
+    title: text25("title").notNull(),
+    description: text25("description"),
+    message: text25("message"),
+    status: text25("status").notNull().default("published"),
+    programId: text25("program_id").references(() => programs.id, { onDelete: "cascade" }),
+    isAdmin: boolean6("is_admin").notNull().default(false),
+    audienceAcademy: boolean6("audience_academy").notNull().default(false),
+    audienceCompetition: boolean6("audience_competition").notNull().default(false),
+    emailEnabled: boolean6("email_enabled").notNull().default(false),
+    emailSent: boolean6("email_sent").notNull().default(false),
+    emailSentAt: timestamp25("email_sent_at"),
+    emailError: text25("email_error"),
+    deletedAt: timestamp25("deleted_at"),
+    createdAt: timestamp25("created_at").notNull().defaultNow(),
+    updatedAt: timestamp25("updated_at").notNull().defaultNow()
   },
-  (table) => [index21("announcements_program_id_idx").on(table.programId)]
+  (table) => [
+    index23("announcements_program_id_idx").on(table.programId),
+    index23("announcements_status_idx").on(table.status),
+    index23("announcements_is_admin_idx").on(table.isAdmin)
+  ]
 );
-var announcementsRelations = relations21(announcements, ({ one }) => ({
+var announcementsRelations = relations23(announcements, ({ one }) => ({
   program: one(programs, {
     fields: [announcements.programId],
     references: [programs.id]
@@ -763,69 +849,69 @@ var announcementsRelations = relations21(announcements, ({ one }) => ({
 }));
 
 // playground/leaderboard-history.schema.ts
-import { pgTable as pgTable24, timestamp as timestamp24, uuid } from "drizzle-orm/pg-core";
+import { pgTable as pgTable26, timestamp as timestamp26, uuid } from "drizzle-orm/pg-core";
 import { jsonb as jsonb2 } from "drizzle-orm/pg-core";
-var leaderboardHistories = pgTable24("leaderboardHistories", {
+var leaderboardHistories = pgTable26("leaderboardHistories", {
   id: uuid("id").primaryKey().defaultRandom(),
   jsonData: jsonb2("json_data").notNull(),
-  createdAt: timestamp24("created_at").notNull().defaultNow(),
-  updatedAt: timestamp24("updated_at").notNull().defaultNow()
+  createdAt: timestamp26("created_at").notNull().defaultNow(),
+  updatedAt: timestamp26("updated_at").notNull().defaultNow()
 });
 
 // playground/user-playground.schema.ts
-import { index as index22, pgTable as pgTable25, text as text24, timestamp as timestamp25, uuid as uuid2 } from "drizzle-orm/pg-core";
-var userPlaygrounds = pgTable25(
+import { index as index24, pgTable as pgTable27, text as text26, timestamp as timestamp27, uuid as uuid2 } from "drizzle-orm/pg-core";
+var userPlaygrounds = pgTable27(
   "userPlaygrounds",
   {
     id: uuid2("id").primaryKey().defaultRandom(),
-    userId: text24("user_id").notNull().unique().references(() => users.id, { onDelete: "cascade" }),
-    username: text24("username").notNull(),
-    virtualPoint: text24("virtual_point").notNull().default("0"),
-    mainEventCurrency: text24("main_event_currency").notNull().default("0"),
-    deletedAt: timestamp25("deleted_at"),
-    createdAt: timestamp25("created_at").notNull().defaultNow(),
-    updatedAt: timestamp25("updated_at").notNull().defaultNow()
+    userId: text26("user_id").notNull().unique().references(() => users.id, { onDelete: "cascade" }),
+    username: text26("username").notNull(),
+    virtualPoint: text26("virtual_point").notNull().default("0"),
+    mainEventCurrency: text26("main_event_currency").notNull().default("0"),
+    deletedAt: timestamp27("deleted_at"),
+    createdAt: timestamp27("created_at").notNull().defaultNow(),
+    updatedAt: timestamp27("updated_at").notNull().defaultNow()
   },
-  (table) => [index22("userPlaygrounds_userId_idx").on(table.userId)]
+  (table) => [index24("userPlaygrounds_userId_idx").on(table.userId)]
 );
 
 // playground/user-playground-detention.schema.ts
-import { boolean as boolean5, index as index23, pgTable as pgTable26, text as text25, timestamp as timestamp26, uuid as uuid3 } from "drizzle-orm/pg-core";
-var userPlaygroundDetentions = pgTable26(
+import { boolean as boolean7, index as index25, pgTable as pgTable28, text as text27, timestamp as timestamp28, uuid as uuid3 } from "drizzle-orm/pg-core";
+var userPlaygroundDetentions = pgTable28(
   "userPlaygroundDetentions",
   {
     id: uuid3("id").primaryKey().defaultRandom(),
     userPlaygroundId: uuid3("user_playground_id").notNull().unique().references(() => userPlaygrounds.id, { onDelete: "cascade" }),
-    description: text25("description").notNull(),
-    penaltyPoint: text25("penalty_point").notNull(),
+    description: text27("description").notNull(),
+    penaltyPoint: text27("penalty_point").notNull(),
     state: detentionStateEnum("state").notNull(),
-    isRead: boolean5("is_read").notNull().default(false),
-    deletedAt: timestamp26("deleted_at"),
-    createdAt: timestamp26("created_at").notNull().defaultNow(),
-    updatedAt: timestamp26("updated_at").notNull().defaultNow()
+    isRead: boolean7("is_read").notNull().default(false),
+    deletedAt: timestamp28("deleted_at"),
+    createdAt: timestamp28("created_at").notNull().defaultNow(),
+    updatedAt: timestamp28("updated_at").notNull().defaultNow()
   },
-  (table) => [index23("userPlaygroundDetentions_userPlaygroundId_idx").on(table.userPlaygroundId)]
+  (table) => [index25("userPlaygroundDetentions_userPlaygroundId_idx").on(table.userPlaygroundId)]
 );
 
 // games/game.schema.ts
-import { relations as relations26 } from "drizzle-orm";
-import { boolean as boolean8, pgTable as pgTable31, text as text29, timestamp as timestamp31 } from "drizzle-orm/pg-core";
+import { relations as relations28 } from "drizzle-orm";
+import { boolean as boolean10, pgTable as pgTable33, text as text31, timestamp as timestamp33 } from "drizzle-orm/pg-core";
 
 // games/game-developer.schema.ts
-import { relations as relations22 } from "drizzle-orm";
-import { pgTable as pgTable27, text as text26, timestamp as timestamp27 } from "drizzle-orm/pg-core";
-var gameDevelopers = pgTable27("gameDevelopers", {
-  id: text26("id").primaryKey(),
-  gameId: text26("gameId").references(() => games.id, { onDelete: "cascade" }).notNull(),
-  name: text26("name").notNull(),
-  description: text26("description"),
-  imageUrl: text26("imageUrl"),
-  instagramUrl: text26("instagramUrl"),
-  linkedInUrl: text26("linkedInUrl"),
-  createdAt: timestamp27("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp27("updatedAt").notNull().defaultNow()
+import { relations as relations24 } from "drizzle-orm";
+import { pgTable as pgTable29, text as text28, timestamp as timestamp29 } from "drizzle-orm/pg-core";
+var gameDevelopers = pgTable29("gameDevelopers", {
+  id: text28("id").primaryKey(),
+  gameId: text28("gameId").references(() => games.id, { onDelete: "cascade" }).notNull(),
+  name: text28("name").notNull(),
+  description: text28("description"),
+  imageUrl: text28("imageUrl"),
+  instagramUrl: text28("instagramUrl"),
+  linkedInUrl: text28("linkedInUrl"),
+  createdAt: timestamp29("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp29("updatedAt").notNull().defaultNow()
 });
-var gameDevelopersRelations = relations22(gameDevelopers, ({ one }) => ({
+var gameDevelopersRelations = relations24(gameDevelopers, ({ one }) => ({
   game: one(games, {
     fields: [gameDevelopers.gameId],
     references: [games.id]
@@ -833,17 +919,17 @@ var gameDevelopersRelations = relations22(gameDevelopers, ({ one }) => ({
 }));
 
 // games/game-rule.schema.ts
-import { relations as relations23 } from "drizzle-orm";
-import { pgTable as pgTable28, text as text27, timestamp as timestamp28 } from "drizzle-orm/pg-core";
-var gameRules = pgTable28("gameRules", {
-  id: text27("id").primaryKey(),
-  gameId: text27("gameId").references(() => games.id, { onDelete: "cascade" }).notNull(),
-  title: text27("title").notNull(),
-  rule: text27("rule").notNull(),
-  createdAt: timestamp28("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp28("updatedAt").notNull().defaultNow()
+import { relations as relations25 } from "drizzle-orm";
+import { pgTable as pgTable30, text as text29, timestamp as timestamp30 } from "drizzle-orm/pg-core";
+var gameRules = pgTable30("gameRules", {
+  id: text29("id").primaryKey(),
+  gameId: text29("gameId").references(() => games.id, { onDelete: "cascade" }).notNull(),
+  title: text29("title").notNull(),
+  rule: text29("rule").notNull(),
+  createdAt: timestamp30("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp30("updatedAt").notNull().defaultNow()
 });
-var gameRulesRelations = relations23(gameRules, ({ one }) => ({
+var gameRulesRelations = relations25(gameRules, ({ one }) => ({
   game: one(games, {
     fields: [gameRules.gameId],
     references: [games.id]
@@ -851,24 +937,24 @@ var gameRulesRelations = relations23(gameRules, ({ one }) => ({
 }));
 
 // games/user-play-game-history.schema.ts
-import { relations as relations25 } from "drizzle-orm";
-import { boolean as boolean7, pgTable as pgTable30, text as text28, timestamp as timestamp30, uuid as uuid5 } from "drizzle-orm/pg-core";
+import { relations as relations27 } from "drizzle-orm";
+import { boolean as boolean9, pgTable as pgTable32, text as text30, timestamp as timestamp32, uuid as uuid5 } from "drizzle-orm/pg-core";
 
 // tokens/playground-token.schema.ts
-import { relations as relations24 } from "drizzle-orm";
-import { boolean as boolean6, pgTable as pgTable29, timestamp as timestamp29, uuid as uuid4, varchar } from "drizzle-orm/pg-core";
-var playgroundTokens = pgTable29("playgroundTokens", {
+import { relations as relations26 } from "drizzle-orm";
+import { boolean as boolean8, pgTable as pgTable31, timestamp as timestamp31, uuid as uuid4, varchar } from "drizzle-orm/pg-core";
+var playgroundTokens = pgTable31("playgroundTokens", {
   id: uuid4("id").primaryKey().defaultRandom(),
   userPlaygroundId: uuid4("userPlaygroundId").references(() => userPlaygrounds.id, { onDelete: "cascade" }).notNull(),
   code: varchar("code", { length: 6 }).notNull().unique(),
   tokenType: tokenTypeEnum("tokenType").notNull(),
-  isUsed: boolean6("isUsed").notNull().default(false),
-  usedAt: timestamp29("usedAt"),
-  deletedAt: timestamp29("deletedAt"),
-  createdAt: timestamp29("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp29("updatedAt").notNull().defaultNow()
+  isUsed: boolean8("isUsed").notNull().default(false),
+  usedAt: timestamp31("usedAt"),
+  deletedAt: timestamp31("deletedAt"),
+  createdAt: timestamp31("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp31("updatedAt").notNull().defaultNow()
 });
-var playgroundTokensRelations = relations24(playgroundTokens, ({ one }) => ({
+var playgroundTokensRelations = relations26(playgroundTokens, ({ one }) => ({
   userPlayground: one(userPlaygrounds, {
     fields: [playgroundTokens.userPlaygroundId],
     references: [userPlaygrounds.id]
@@ -876,19 +962,19 @@ var playgroundTokensRelations = relations24(playgroundTokens, ({ one }) => ({
 }));
 
 // games/user-play-game-history.schema.ts
-var userPlayGameHistories = pgTable30("userPlayGameHistories", {
-  id: text28("id").primaryKey(),
+var userPlayGameHistories = pgTable32("userPlayGameHistories", {
+  id: text30("id").primaryKey(),
   userPlaygroundId: uuid5("userPlaygroundId").references(() => userPlaygrounds.id, { onDelete: "cascade" }).notNull(),
-  gameId: text28("gameId").references(() => games.id, { onDelete: "cascade" }).notNull(),
+  gameId: text30("gameId").references(() => games.id, { onDelete: "cascade" }).notNull(),
   tokenUsedId: uuid5("tokenUsedId").references(() => playgroundTokens.id, {
     onDelete: "set null"
   }),
-  isFinished: boolean7("isFinished").notNull().default(false),
-  finishedAt: timestamp30("finishedAt"),
-  createdAt: timestamp30("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp30("updatedAt").notNull().defaultNow()
+  isFinished: boolean9("isFinished").notNull().default(false),
+  finishedAt: timestamp32("finishedAt"),
+  createdAt: timestamp32("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp32("updatedAt").notNull().defaultNow()
 });
-var userPlayGameHistoriesRelations = relations25(userPlayGameHistories, ({ one }) => ({
+var userPlayGameHistoriesRelations = relations27(userPlayGameHistories, ({ one }) => ({
   userPlayground: one(userPlaygrounds, {
     fields: [userPlayGameHistories.userPlaygroundId],
     references: [userPlaygrounds.id]
@@ -904,44 +990,44 @@ var userPlayGameHistoriesRelations = relations25(userPlayGameHistories, ({ one }
 }));
 
 // games/game.schema.ts
-var games = pgTable31("games", {
-  id: text29("id").primaryKey(),
-  name: text29("name").notNull(),
-  arcadeCode: text29("arcadeCode").notNull().unique(),
-  arcadeUrl: text29("arcadeUrl"),
-  description: text29("description"),
-  rules: text29("rules").array(),
-  isGetPoint: boolean8("isGetPoint").notNull().default(false),
+var games = pgTable33("games", {
+  id: text31("id").primaryKey(),
+  name: text31("name").notNull(),
+  arcadeCode: text31("arcadeCode").notNull().unique(),
+  arcadeUrl: text31("arcadeUrl"),
+  description: text31("description"),
+  rules: text31("rules").array(),
+  isGetPoint: boolean10("isGetPoint").notNull().default(false),
   orientation: gameOrientationEnum("orientation").notNull().default("VERTICAL"),
-  createdAt: timestamp31("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp31("updatedAt").notNull().defaultNow()
+  createdAt: timestamp33("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp33("updatedAt").notNull().defaultNow()
 });
-var gamesRelations = relations26(games, ({ many }) => ({
+var gamesRelations = relations28(games, ({ many }) => ({
   gameRules: many(gameRules),
   gameDevelopers: many(gameDevelopers),
   userPlayGameHistories: many(userPlayGameHistories)
 }));
 
 // tokens/playground-expense-history.schema.ts
-import { relations as relations27 } from "drizzle-orm";
-import { index as index24, integer as integer3, pgTable as pgTable32, text as text30, timestamp as timestamp32, uuid as uuid6 } from "drizzle-orm/pg-core";
-var playgroundExpenseHistories = pgTable32(
+import { relations as relations29 } from "drizzle-orm";
+import { index as index26, integer as integer3, pgTable as pgTable34, text as text32, timestamp as timestamp34, uuid as uuid6 } from "drizzle-orm/pg-core";
+var playgroundExpenseHistories = pgTable34(
   "playgroundExpenseHistories",
   {
-    id: text30("id").primaryKey(),
+    id: text32("id").primaryKey(),
     userPlaygroundId: uuid6("userPlaygroundId").references(() => userPlaygrounds.id, {
       onDelete: "cascade"
     }),
-    description: text30("description"),
+    description: text32("description"),
     amount: integer3("amount").notNull(),
-    createdAt: timestamp32("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp32("updatedAt").notNull().defaultNow()
+    createdAt: timestamp34("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp34("updatedAt").notNull().defaultNow()
   },
   (table) => [
-    index24("playgroundExpenseHistories_userPlaygroundId_idx").on(table.userPlaygroundId)
+    index26("playgroundExpenseHistories_userPlaygroundId_idx").on(table.userPlaygroundId)
   ]
 );
-var playgroundExpenseHistoriesRelations = relations27(
+var playgroundExpenseHistoriesRelations = relations29(
   playgroundExpenseHistories,
   ({ one }) => ({
     userPlayground: one(userPlaygrounds, {
@@ -952,24 +1038,24 @@ var playgroundExpenseHistoriesRelations = relations27(
 );
 
 // tokens/playground-reward-history.schema.ts
-import { relations as relations28 } from "drizzle-orm";
-import { index as index25, integer as integer4, pgTable as pgTable33, text as text31, timestamp as timestamp33, uuid as uuid7 } from "drizzle-orm/pg-core";
-var playgroundRewardHistories = pgTable33(
+import { relations as relations30 } from "drizzle-orm";
+import { index as index27, integer as integer4, pgTable as pgTable35, text as text33, timestamp as timestamp35, uuid as uuid7 } from "drizzle-orm/pg-core";
+var playgroundRewardHistories = pgTable35(
   "playgroundRewardHistories",
   {
-    id: text31("id").primaryKey(),
+    id: text33("id").primaryKey(),
     userPlaygroundId: uuid7("userPlaygroundId").references(() => userPlaygrounds.id, {
       onDelete: "cascade"
     }),
-    description: text31("description"),
+    description: text33("description"),
     rewardType: rewardTypeEnum("rewardType").notNull(),
     amount: integer4("amount").notNull(),
-    createdAt: timestamp33("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp33("updatedAt").notNull().defaultNow()
+    createdAt: timestamp35("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp35("updatedAt").notNull().defaultNow()
   },
-  (table) => [index25("playgroundRewardHistories_userPlaygroundId_idx").on(table.userPlaygroundId)]
+  (table) => [index27("playgroundRewardHistories_userPlaygroundId_idx").on(table.userPlaygroundId)]
 );
-var playgroundRewardHistoriesRelations = relations28(
+var playgroundRewardHistoriesRelations = relations30(
   playgroundRewardHistories,
   ({ one }) => ({
     userPlayground: one(userPlaygrounds, {
@@ -980,33 +1066,33 @@ var playgroundRewardHistoriesRelations = relations28(
 );
 
 // ads/ad-watch-history.schema.ts
-import { relations as relations29 } from "drizzle-orm";
-import { pgTable as pgTable35, text as text33, timestamp as timestamp35, uuid as uuid8 } from "drizzle-orm/pg-core";
+import { relations as relations31 } from "drizzle-orm";
+import { pgTable as pgTable37, text as text35, timestamp as timestamp37, uuid as uuid8 } from "drizzle-orm/pg-core";
 
 // ads/advertisement.schema.ts
-import { boolean as boolean9, integer as integer5, pgTable as pgTable34, text as text32, timestamp as timestamp34 } from "drizzle-orm/pg-core";
-var advertisements = pgTable34("advertisements", {
-  id: text32("id").primaryKey(),
-  contentUrl: text32("contentUrl").notNull(),
-  isVideo: boolean9("isVideo").notNull().default(false),
+import { boolean as boolean11, integer as integer5, pgTable as pgTable36, text as text34, timestamp as timestamp36 } from "drizzle-orm/pg-core";
+var advertisements = pgTable36("advertisements", {
+  id: text34("id").primaryKey(),
+  contentUrl: text34("contentUrl").notNull(),
+  isVideo: boolean11("isVideo").notNull().default(false),
   contentLength: integer5("contentLength"),
-  createdAt: timestamp34("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp34("updatedAt").notNull().defaultNow()
+  createdAt: timestamp36("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp36("updatedAt").notNull().defaultNow()
 });
 
 // ads/ad-watch-history.schema.ts
-var adWatchHistories = pgTable35("adWatchHistories", {
-  id: text33("id").primaryKey(),
+var adWatchHistories = pgTable37("adWatchHistories", {
+  id: text35("id").primaryKey(),
   userPlaygroundId: uuid8("userPlaygroundId").references(() => userPlaygrounds.id, {
     onDelete: "cascade"
   }),
-  adId: text33("adId").references(() => advertisements.id, { onDelete: "cascade" }),
-  referer: text33("referer"),
-  watchedAt: timestamp35("watchedAt").notNull(),
-  createdAt: timestamp35("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp35("updatedAt").notNull().defaultNow()
+  adId: text35("adId").references(() => advertisements.id, { onDelete: "cascade" }),
+  referer: text35("referer"),
+  watchedAt: timestamp37("watchedAt").notNull(),
+  createdAt: timestamp37("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp37("updatedAt").notNull().defaultNow()
 });
-var adWatchHistoriesRelations = relations29(adWatchHistories, ({ one }) => ({
+var adWatchHistoriesRelations = relations31(adWatchHistories, ({ one }) => ({
   userPlayground: one(userPlaygrounds, {
     fields: [adWatchHistories.userPlaygroundId],
     references: [userPlaygrounds.id]
@@ -1018,22 +1104,22 @@ var adWatchHistoriesRelations = relations29(adWatchHistories, ({ one }) => ({
 }));
 
 // ads/ad-watch-session.schema.ts
-import { relations as relations30 } from "drizzle-orm";
-import { integer as integer6, pgTable as pgTable36, text as text34, timestamp as timestamp36, uuid as uuid9 } from "drizzle-orm/pg-core";
-var adWatchSessions = pgTable36("adWatchSessions", {
-  id: text34("id").primaryKey(),
+import { relations as relations32 } from "drizzle-orm";
+import { integer as integer6, pgTable as pgTable38, text as text36, timestamp as timestamp38, uuid as uuid9 } from "drizzle-orm/pg-core";
+var adWatchSessions = pgTable38("adWatchSessions", {
+  id: text36("id").primaryKey(),
   userPlaygroundId: uuid9("userPlaygroundId").references(() => userPlaygrounds.id, {
     onDelete: "cascade"
   }),
-  adId: text34("adId").references(() => advertisements.id, { onDelete: "cascade" }),
+  adId: text36("adId").references(() => advertisements.id, { onDelete: "cascade" }),
   adLength: integer6("adLength"),
   startTimeUnix: integer6("startTimeUnix").notNull(),
   lockUntil: integer6("lockUntil"),
-  finishedAt: timestamp36("finishedAt"),
-  createdAt: timestamp36("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp36("updatedAt").notNull().defaultNow()
+  finishedAt: timestamp38("finishedAt"),
+  createdAt: timestamp38("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp38("updatedAt").notNull().defaultNow()
 });
-var adWatchSessionsRelations = relations30(adWatchSessions, ({ one }) => ({
+var adWatchSessionsRelations = relations32(adWatchSessions, ({ one }) => ({
   userPlayground: one(userPlaygrounds, {
     fields: [adWatchSessions.userPlaygroundId],
     references: [userPlaygrounds.id]
@@ -1045,29 +1131,29 @@ var adWatchSessionsRelations = relations30(adWatchSessions, ({ one }) => ({
 }));
 
 // quiz/main-event-mini-quiz.schema.ts
-import { relations as relations34 } from "drizzle-orm";
-import { index as index29, pgTable as pgTable40, text as text38, timestamp as timestamp40 } from "drizzle-orm/pg-core";
+import { relations as relations36 } from "drizzle-orm";
+import { index as index31, pgTable as pgTable42, text as text40, timestamp as timestamp42 } from "drizzle-orm/pg-core";
 
 // quiz/main-event-mini-quiz-attempt.schema.ts
-import { relations as relations31 } from "drizzle-orm";
-import { index as index26, json, pgTable as pgTable37, text as text35, timestamp as timestamp37 } from "drizzle-orm/pg-core";
-var mainEventMiniQuizAttempts = pgTable37(
+import { relations as relations33 } from "drizzle-orm";
+import { index as index28, json, pgTable as pgTable39, text as text37, timestamp as timestamp39 } from "drizzle-orm/pg-core";
+var mainEventMiniQuizAttempts = pgTable39(
   "mainEventMiniQuizAttempts",
   {
-    id: text35("id").primaryKey(),
-    quizId: text35("quizId").references(() => mainEventMiniQuizzes.id, { onDelete: "cascade" }),
-    userId: text35("userId").references(() => users.id, { onDelete: "cascade" }),
+    id: text37("id").primaryKey(),
+    quizId: text37("quizId").references(() => mainEventMiniQuizzes.id, { onDelete: "cascade" }),
+    userId: text37("userId").references(() => users.id, { onDelete: "cascade" }),
     answerJson: json("answerJson"),
-    attemptedAt: timestamp37("attemptedAt"),
-    createdAt: timestamp37("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp37("updatedAt").notNull().defaultNow()
+    attemptedAt: timestamp39("attemptedAt"),
+    createdAt: timestamp39("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp39("updatedAt").notNull().defaultNow()
   },
   (table) => [
-    index26("mainEventMiniQuizAttempts_quizId_idx").on(table.quizId),
-    index26("mainEventMiniQuizAttempts_userId_idx").on(table.userId)
+    index28("mainEventMiniQuizAttempts_quizId_idx").on(table.quizId),
+    index28("mainEventMiniQuizAttempts_userId_idx").on(table.userId)
   ]
 );
-var mainEventMiniQuizAttemptsRelations = relations31(
+var mainEventMiniQuizAttemptsRelations = relations33(
   mainEventMiniQuizAttempts,
   ({ one }) => ({
     quiz: one(mainEventMiniQuizzes, {
@@ -1082,27 +1168,27 @@ var mainEventMiniQuizAttemptsRelations = relations31(
 );
 
 // quiz/main-event-mini-quiz-question.schema.ts
-import { relations as relations33 } from "drizzle-orm";
-import { index as index28, pgTable as pgTable39, text as text37, timestamp as timestamp39 } from "drizzle-orm/pg-core";
+import { relations as relations35 } from "drizzle-orm";
+import { index as index30, pgTable as pgTable41, text as text39, timestamp as timestamp41 } from "drizzle-orm/pg-core";
 
 // quiz/main-event-mini-quiz-question-option.schema.ts
-import { relations as relations32 } from "drizzle-orm";
-import { boolean as boolean10, index as index27, pgTable as pgTable38, text as text36, timestamp as timestamp38 } from "drizzle-orm/pg-core";
-var mainEventMiniQuizQuestionOptions = pgTable38(
+import { relations as relations34 } from "drizzle-orm";
+import { boolean as boolean12, index as index29, pgTable as pgTable40, text as text38, timestamp as timestamp40 } from "drizzle-orm/pg-core";
+var mainEventMiniQuizQuestionOptions = pgTable40(
   "mainEventMiniQuizQuestionOptions",
   {
-    id: text36("id").primaryKey(),
-    questionId: text36("questionId").references(() => mainEventMiniQuizQuestions.id, {
+    id: text38("id").primaryKey(),
+    questionId: text38("questionId").references(() => mainEventMiniQuizQuestions.id, {
       onDelete: "cascade"
     }),
-    option: text36("option").notNull(),
-    isAnswer: boolean10("isAnswer").notNull().default(false),
-    createdAt: timestamp38("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp38("updatedAt").notNull().defaultNow()
+    option: text38("option").notNull(),
+    isAnswer: boolean12("isAnswer").notNull().default(false),
+    createdAt: timestamp40("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp40("updatedAt").notNull().defaultNow()
   },
-  (table) => [index27("mainEventMiniQuizQuestionOptions_questionId_idx").on(table.questionId)]
+  (table) => [index29("mainEventMiniQuizQuestionOptions_questionId_idx").on(table.questionId)]
 );
-var mainEventMiniQuizQuestionOptionsRelations = relations32(
+var mainEventMiniQuizQuestionOptionsRelations = relations34(
   mainEventMiniQuizQuestionOptions,
   ({ one }) => ({
     question: one(mainEventMiniQuizQuestions, {
@@ -1113,18 +1199,18 @@ var mainEventMiniQuizQuestionOptionsRelations = relations32(
 );
 
 // quiz/main-event-mini-quiz-question.schema.ts
-var mainEventMiniQuizQuestions = pgTable39(
+var mainEventMiniQuizQuestions = pgTable41(
   "mainEventMiniQuizQuestions",
   {
-    id: text37("id").primaryKey(),
-    quizId: text37("quizId").references(() => mainEventMiniQuizzes.id, { onDelete: "cascade" }),
-    question: text37("question").notNull(),
-    createdAt: timestamp39("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp39("updatedAt").notNull().defaultNow()
+    id: text39("id").primaryKey(),
+    quizId: text39("quizId").references(() => mainEventMiniQuizzes.id, { onDelete: "cascade" }),
+    question: text39("question").notNull(),
+    createdAt: timestamp41("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp41("updatedAt").notNull().defaultNow()
   },
-  (table) => [index28("mainEventMiniQuizQuestions_quizId_idx").on(table.quizId)]
+  (table) => [index30("mainEventMiniQuizQuestions_quizId_idx").on(table.quizId)]
 );
-var mainEventMiniQuizQuestionsRelations = relations33(
+var mainEventMiniQuizQuestionsRelations = relations35(
   mainEventMiniQuizQuestions,
   ({ one, many }) => ({
     quiz: one(mainEventMiniQuizzes, {
@@ -1136,45 +1222,45 @@ var mainEventMiniQuizQuestionsRelations = relations33(
 );
 
 // quiz/main-event-mini-quiz.schema.ts
-var mainEventMiniQuizzes = pgTable40(
+var mainEventMiniQuizzes = pgTable42(
   "mainEventMiniQuizzes",
   {
-    id: text38("id").primaryKey(),
-    quizName: text38("quizName").notNull(),
-    createdAt: timestamp40("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp40("updatedAt").notNull().defaultNow()
+    id: text40("id").primaryKey(),
+    quizName: text40("quizName").notNull(),
+    createdAt: timestamp42("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp42("updatedAt").notNull().defaultNow()
   },
-  (table) => [index29("mainEventMiniQuizzes_quizName_idx").on(table.quizName)]
+  (table) => [index31("mainEventMiniQuizzes_quizName_idx").on(table.quizName)]
 );
-var mainEventMiniQuizzesRelations = relations34(mainEventMiniQuizzes, ({ many }) => ({
+var mainEventMiniQuizzesRelations = relations36(mainEventMiniQuizzes, ({ many }) => ({
   questions: many(mainEventMiniQuizQuestions),
   attempts: many(mainEventMiniQuizAttempts)
 }));
 
 // quiz/mini-quiz.schema.ts
-import { relations as relations37 } from "drizzle-orm";
-import { index as index32, pgTable as pgTable43, text as text41, timestamp as timestamp43 } from "drizzle-orm/pg-core";
+import { relations as relations39 } from "drizzle-orm";
+import { index as index34, pgTable as pgTable45, text as text43, timestamp as timestamp45 } from "drizzle-orm/pg-core";
 
 // quiz/mini-quiz-attempt.schema.ts
-import { relations as relations35 } from "drizzle-orm";
-import { index as index30, json as json2, pgTable as pgTable41, text as text39, timestamp as timestamp41 } from "drizzle-orm/pg-core";
-var miniQuizAttempts = pgTable41(
+import { relations as relations37 } from "drizzle-orm";
+import { index as index32, json as json2, pgTable as pgTable43, text as text41, timestamp as timestamp43 } from "drizzle-orm/pg-core";
+var miniQuizAttempts = pgTable43(
   "miniQuizAttempts",
   {
-    id: text39("id").primaryKey(),
-    quizId: text39("quizId").references(() => miniQuizzes.id, { onDelete: "cascade" }),
-    userId: text39("userId").references(() => users.id, { onDelete: "cascade" }),
+    id: text41("id").primaryKey(),
+    quizId: text41("quizId").references(() => miniQuizzes.id, { onDelete: "cascade" }),
+    userId: text41("userId").references(() => users.id, { onDelete: "cascade" }),
     answerJson: json2("answerJson"),
-    attemptedAt: timestamp41("attemptedAt"),
-    createdAt: timestamp41("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp41("updatedAt").notNull().defaultNow()
+    attemptedAt: timestamp43("attemptedAt"),
+    createdAt: timestamp43("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp43("updatedAt").notNull().defaultNow()
   },
   (table) => [
-    index30("miniQuizAttempts_quizId_idx").on(table.quizId),
-    index30("miniQuizAttempts_userId_idx").on(table.userId)
+    index32("miniQuizAttempts_quizId_idx").on(table.quizId),
+    index32("miniQuizAttempts_userId_idx").on(table.userId)
   ]
 );
-var miniQuizAttemptsRelations = relations35(miniQuizAttempts, ({ one }) => ({
+var miniQuizAttemptsRelations = relations37(miniQuizAttempts, ({ one }) => ({
   quiz: one(miniQuizzes, {
     fields: [miniQuizAttempts.quizId],
     references: [miniQuizzes.id]
@@ -1186,21 +1272,21 @@ var miniQuizAttemptsRelations = relations35(miniQuizAttempts, ({ one }) => ({
 }));
 
 // quiz/mini-quiz-question.schema.ts
-import { relations as relations36 } from "drizzle-orm";
-import { boolean as boolean11, index as index31, pgTable as pgTable42, text as text40, timestamp as timestamp42 } from "drizzle-orm/pg-core";
-var miniQuizQuestions = pgTable42(
+import { relations as relations38 } from "drizzle-orm";
+import { boolean as boolean13, index as index33, pgTable as pgTable44, text as text42, timestamp as timestamp44 } from "drizzle-orm/pg-core";
+var miniQuizQuestions = pgTable44(
   "miniQuizQuestions",
   {
-    id: text40("id").primaryKey(),
-    quizId: text40("quizId").references(() => miniQuizzes.id, { onDelete: "cascade" }),
-    question: text40("question").notNull(),
-    isTrue: boolean11("isTrue"),
-    createdAt: timestamp42("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp42("updatedAt").notNull().defaultNow()
+    id: text42("id").primaryKey(),
+    quizId: text42("quizId").references(() => miniQuizzes.id, { onDelete: "cascade" }),
+    question: text42("question").notNull(),
+    isTrue: boolean13("isTrue"),
+    createdAt: timestamp44("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp44("updatedAt").notNull().defaultNow()
   },
-  (table) => [index31("miniQuizQuestions_quizId_idx").on(table.quizId)]
+  (table) => [index33("miniQuizQuestions_quizId_idx").on(table.quizId)]
 );
-var miniQuizQuestionsRelations = relations36(miniQuizQuestions, ({ one }) => ({
+var miniQuizQuestionsRelations = relations38(miniQuizQuestions, ({ one }) => ({
   quiz: one(miniQuizzes, {
     fields: [miniQuizQuestions.quizId],
     references: [miniQuizzes.id]
@@ -1208,69 +1294,69 @@ var miniQuizQuestionsRelations = relations36(miniQuizQuestions, ({ one }) => ({
 }));
 
 // quiz/mini-quiz.schema.ts
-var miniQuizzes = pgTable43(
+var miniQuizzes = pgTable45(
   "miniQuizzes",
   {
-    id: text41("id").primaryKey(),
-    quizName: text41("quizName").notNull(),
-    createdAt: timestamp43("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp43("updatedAt").notNull().defaultNow()
+    id: text43("id").primaryKey(),
+    quizName: text43("quizName").notNull(),
+    createdAt: timestamp45("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp45("updatedAt").notNull().defaultNow()
   },
-  (table) => [index32("miniQuizzes_quizName_idx").on(table.quizName)]
+  (table) => [index34("miniQuizzes_quizName_idx").on(table.quizName)]
 );
-var miniQuizzesRelations = relations37(miniQuizzes, ({ many }) => ({
+var miniQuizzesRelations = relations39(miniQuizzes, ({ many }) => ({
   questions: many(miniQuizQuestions),
   attempts: many(miniQuizAttempts)
 }));
 
 // exhibition/company-exhibition.schema.ts
-import { pgTable as pgTable44, text as text42, timestamp as timestamp44 } from "drizzle-orm/pg-core";
-var companyExhibitions = pgTable44("companyExhibitions", {
-  id: text42("id").primaryKey(),
-  name: text42("name").notNull(),
-  location: text42("location"),
-  iconUrl: text42("iconUrl"),
-  description: text42("description"),
-  tags: text42("tags"),
-  benefits: text42("benefits"),
-  vision: text42("vision"),
-  mission: text42("mission"),
-  documentationLinks: text42("documentationLinks"),
-  websiteLink: text42("websiteLink"),
-  createdAt: timestamp44("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp44("updatedAt").notNull().defaultNow()
+import { pgTable as pgTable46, text as text44, timestamp as timestamp46 } from "drizzle-orm/pg-core";
+var companyExhibitions = pgTable46("companyExhibitions", {
+  id: text44("id").primaryKey(),
+  name: text44("name").notNull(),
+  location: text44("location"),
+  iconUrl: text44("iconUrl"),
+  description: text44("description"),
+  tags: text44("tags"),
+  benefits: text44("benefits"),
+  vision: text44("vision"),
+  mission: text44("mission"),
+  documentationLinks: text44("documentationLinks"),
+  websiteLink: text44("websiteLink"),
+  createdAt: timestamp46("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp46("updatedAt").notNull().defaultNow()
 });
 
 // exhibition/company-exhibition-vacancies.schema.ts
-import { relations as relations38 } from "drizzle-orm";
-import { boolean as boolean12, index as index33, pgTable as pgTable45, text as text43, timestamp as timestamp45 } from "drizzle-orm/pg-core";
-var companyExhibitionVacancies = pgTable45(
+import { relations as relations40 } from "drizzle-orm";
+import { boolean as boolean14, index as index35, pgTable as pgTable47, text as text45, timestamp as timestamp47 } from "drizzle-orm/pg-core";
+var companyExhibitionVacancies = pgTable47(
   "companyExhibitionVacancies",
   {
-    id: text43("id").primaryKey(),
-    companyExhibitionId: text43("companyExhibitionId").references(() => companyExhibitions.id, {
+    id: text45("id").primaryKey(),
+    companyExhibitionId: text45("companyExhibitionId").references(() => companyExhibitions.id, {
       onDelete: "cascade"
     }),
-    position: text43("position").notNull(),
-    tags: text43("tags"),
-    description: text43("description"),
-    benefits: text43("benefits"),
+    position: text45("position").notNull(),
+    tags: text45("tags"),
+    description: text45("description"),
+    benefits: text45("benefits"),
     jobType: vacancyJobTypeEnum("jobType"),
-    salary: text43("salary"),
-    deadline: timestamp45("deadline"),
-    responsibilities: text43("responsibilities"),
-    requirements: text43("requirements"),
-    vacancyUrl: text43("vacancyUrl"),
-    isOpen: boolean12("isOpen").notNull().default(true),
-    createdAt: timestamp45("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp45("updatedAt").notNull().defaultNow()
+    salary: text45("salary"),
+    deadline: timestamp47("deadline"),
+    responsibilities: text45("responsibilities"),
+    requirements: text45("requirements"),
+    vacancyUrl: text45("vacancyUrl"),
+    isOpen: boolean14("isOpen").notNull().default(true),
+    createdAt: timestamp47("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp47("updatedAt").notNull().defaultNow()
   },
   (table) => [
-    index33("companyExhibitionVacancies_companyExhibitionId_idx").on(table.companyExhibitionId),
-    index33("companyExhibitionVacancies_isOpen_idx").on(table.isOpen)
+    index35("companyExhibitionVacancies_companyExhibitionId_idx").on(table.companyExhibitionId),
+    index35("companyExhibitionVacancies_isOpen_idx").on(table.isOpen)
   ]
 );
-var companyExhibitionVacanciesRelations = relations38(
+var companyExhibitionVacanciesRelations = relations40(
   companyExhibitionVacancies,
   ({ one }) => ({
     companyExhibition: one(companyExhibitions, {
@@ -1281,33 +1367,33 @@ var companyExhibitionVacanciesRelations = relations38(
 );
 
 // jobfair/walk-in-interview-applicant.schema.ts
-import { relations as relations41 } from "drizzle-orm";
-import { index as index35, pgTable as pgTable48, text as text46, timestamp as timestamp48, uniqueIndex as uniqueIndex2 } from "drizzle-orm/pg-core";
+import { relations as relations43 } from "drizzle-orm";
+import { index as index37, pgTable as pgTable50, text as text48, timestamp as timestamp50, uniqueIndex as uniqueIndex2 } from "drizzle-orm/pg-core";
 
 // jobfair/walk-in-interview-company-slot.schema.ts
-import { relations as relations40 } from "drizzle-orm";
-import { boolean as boolean13, index as index34, pgTable as pgTable47, text as text45, timestamp as timestamp47 } from "drizzle-orm/pg-core";
+import { relations as relations42 } from "drizzle-orm";
+import { boolean as boolean15, index as index36, pgTable as pgTable49, text as text47, timestamp as timestamp49 } from "drizzle-orm/pg-core";
 
 // jobfair/walk-in-interview-company.schema.ts
-import { relations as relations39 } from "drizzle-orm";
-import { integer as integer7, pgTable as pgTable46, text as text44, timestamp as timestamp46 } from "drizzle-orm/pg-core";
-var walkInInterviewCompanies = pgTable46("walkInInterviewCompanies", {
-  id: text44("id").primaryKey(),
-  name: text44("name").notNull(),
-  description: text44("description"),
-  iconUrl: text44("iconUrl"),
+import { relations as relations41 } from "drizzle-orm";
+import { integer as integer7, pgTable as pgTable48, text as text46, timestamp as timestamp48 } from "drizzle-orm/pg-core";
+var walkInInterviewCompanies = pgTable48("walkInInterviewCompanies", {
+  id: text46("id").primaryKey(),
+  name: text46("name").notNull(),
+  description: text46("description"),
+  iconUrl: text46("iconUrl"),
   slots: integer7("slots"),
-  session: text44("session"),
-  roles: text44("roles"),
-  tags: text44("tags"),
-  benefits: text44("benefits"),
-  criteria: text44("criteria"),
+  session: text46("session"),
+  roles: text46("roles"),
+  tags: text46("tags"),
+  benefits: text46("benefits"),
+  criteria: text46("criteria"),
   currentApplicants: integer7("currentApplicants"),
-  boothLocation: text44("boothLocation"),
-  createdAt: timestamp46("createdAt").notNull().defaultNow(),
-  updatedAt: timestamp46("updatedAt").notNull().defaultNow()
+  boothLocation: text46("boothLocation"),
+  createdAt: timestamp48("createdAt").notNull().defaultNow(),
+  updatedAt: timestamp48("updatedAt").notNull().defaultNow()
 });
-var walkInInterviewCompaniesRelations = relations39(
+var walkInInterviewCompaniesRelations = relations41(
   walkInInterviewCompanies,
   ({ many }) => ({
     slots: many(walkInInterviewCompanySlots)
@@ -1315,22 +1401,22 @@ var walkInInterviewCompaniesRelations = relations39(
 );
 
 // jobfair/walk-in-interview-company-slot.schema.ts
-var walkInInterviewCompanySlots = pgTable47(
+var walkInInterviewCompanySlots = pgTable49(
   "walkInInterviewCompanySlots",
   {
-    id: text45("id").primaryKey(),
-    companyId: text45("companyId").references(() => walkInInterviewCompanies.id, {
+    id: text47("id").primaryKey(),
+    companyId: text47("companyId").references(() => walkInInterviewCompanies.id, {
       onDelete: "cascade"
     }),
-    startTime: timestamp47("startTime").notNull(),
-    endTime: timestamp47("endTime").notNull(),
-    isAvailable: boolean13("isAvailable").notNull().default(true),
-    createdAt: timestamp47("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp47("updatedAt").notNull().defaultNow()
+    startTime: timestamp49("startTime").notNull(),
+    endTime: timestamp49("endTime").notNull(),
+    isAvailable: boolean15("isAvailable").notNull().default(true),
+    createdAt: timestamp49("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp49("updatedAt").notNull().defaultNow()
   },
-  (table) => [index34("walkInInterviewCompanySlots_companyId_idx").on(table.companyId)]
+  (table) => [index36("walkInInterviewCompanySlots_companyId_idx").on(table.companyId)]
 );
-var walkInInterviewCompanySlotsRelations = relations40(
+var walkInInterviewCompanySlotsRelations = relations42(
   walkInInterviewCompanySlots,
   ({ one, many }) => ({
     company: one(walkInInterviewCompanies, {
@@ -1342,30 +1428,30 @@ var walkInInterviewCompanySlotsRelations = relations40(
 );
 
 // jobfair/walk-in-interview-applicant.schema.ts
-var walkInInterviewApplicants = pgTable48(
+var walkInInterviewApplicants = pgTable50(
   "walkInInterviewApplicants",
   {
-    id: text46("id").primaryKey(),
-    userId: text46("userId").references(() => users.id, { onDelete: "cascade" }),
-    resumeUrl: text46("resumeUrl"),
+    id: text48("id").primaryKey(),
+    userId: text48("userId").references(() => users.id, { onDelete: "cascade" }),
+    resumeUrl: text48("resumeUrl"),
     status: interviewApplicantStatusEnum("status").notNull().default("PENDING"),
-    referralCode: text46("referralCode"),
-    appliedSessionId: text46("appliedSessionId").references(
+    referralCode: text48("referralCode"),
+    appliedSessionId: text48("appliedSessionId").references(
       () => walkInInterviewCompanySlots.id,
       { onDelete: "cascade" }
     ),
-    appliedAt: timestamp48("appliedAt"),
-    createdAt: timestamp48("createdAt").notNull().defaultNow(),
-    updatedAt: timestamp48("updatedAt").notNull().defaultNow()
+    appliedAt: timestamp50("appliedAt"),
+    createdAt: timestamp50("createdAt").notNull().defaultNow(),
+    updatedAt: timestamp50("updatedAt").notNull().defaultNow()
   },
   (table) => [
-    index35("walkInInterviewApplicants_userId_idx").on(table.userId),
+    index37("walkInInterviewApplicants_userId_idx").on(table.userId),
     uniqueIndex2("walkInInterviewApplicants_appliedSessionId_unique_idx").on(
       table.appliedSessionId
     )
   ]
 );
-var walkInInterviewApplicantsRelations = relations41(
+var walkInInterviewApplicantsRelations = relations43(
   walkInInterviewApplicants,
   ({ one }) => ({
     user: one(users, {
@@ -1380,140 +1466,178 @@ var walkInInterviewApplicantsRelations = relations41(
 );
 
 // cvclinic/cv-clinic-claim.schema.ts
-import { pgTable as pgTable50, text as text48, timestamp as timestamp49 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable52, text as text50, timestamp as timestamp51 } from "drizzle-orm/pg-core";
 
 // cvclinic/cv-clinic-vouchers.schema.ts
-import { pgTable as pgTable49, text as text47 } from "drizzle-orm/pg-core";
-var cvClinicVouchers = pgTable49("cv_clinic_vouchers", {
-  code: text47("code").primaryKey()
+import { pgTable as pgTable51, text as text49 } from "drizzle-orm/pg-core";
+var cvClinicVouchers = pgTable51("cv_clinic_vouchers", {
+  code: text49("code").primaryKey()
 });
 
 // cvclinic/cv-clinic-claim.schema.ts
-var cvClinicClaims = pgTable50("cv_clinic_claims", {
-  id: text48("id").primaryKey(),
-  userId: text48("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-  usedVoucherCode: text48("used_voucher_code").references(() => cvClinicVouchers.code, {
+var cvClinicClaims = pgTable52("cv_clinic_claims", {
+  id: text50("id").primaryKey(),
+  userId: text50("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  usedVoucherCode: text50("used_voucher_code").references(() => cvClinicVouchers.code, {
     onDelete: "set null"
   }),
-  createdAt: timestamp49("created_at").notNull().defaultNow(),
-  updatedAt: timestamp49("updated_at").notNull().defaultNow()
+  createdAt: timestamp51("created_at").notNull().defaultNow(),
+  updatedAt: timestamp51("updated_at").notNull().defaultNow()
 });
 
+// voting/competition-showcase.schema.ts
+import { pgTable as pgTable53, text as text51, timestamp as timestamp52, uniqueIndex as uniqueIndex3 } from "drizzle-orm/pg-core";
+var competitionShowcases = pgTable53(
+  "competition_showcases",
+  {
+    id: text51("id").primaryKey(),
+    slug: text51("slug").unique(),
+    name: text51("name").notNull(),
+    createdAt: timestamp52("created_at").notNull().defaultNow(),
+    updatedAt: timestamp52("updated_at").notNull().defaultNow()
+  },
+  (table) => [uniqueIndex3("competition_showcases_name_unique").on(table.name)]
+);
+
 // voting/nominee.schema.ts
-import { boolean as boolean14, integer as integer8, pgTable as pgTable51, text as text49, timestamp as timestamp50 } from "drizzle-orm/pg-core";
-var nominees = pgTable51("nominees", {
-  id: text49("id").primaryKey(),
+import { boolean as boolean16, integer as integer8, pgTable as pgTable54, text as text52, timestamp as timestamp53 } from "drizzle-orm/pg-core";
+var nominees = pgTable54("nominees", {
+  id: text52("id").primaryKey(),
   type: nomineeTypeEnum("type").notNull(),
-  name: text49("name").notNull(),
-  developer: text49("developer").notNull(),
-  description: text49("description"),
-  thumbnailUrl: text49("thumbnail_url"),
-  url: text49("url"),
-  isActive: boolean14("is_active").notNull().default(true),
+  name: text52("name").notNull(),
+  developer: text52("developer").notNull(),
+  description: text52("description"),
+  thumbnailUrl: text52("thumbnail_url"),
+  url: text52("url"),
+  isActive: boolean16("is_active").notNull().default(true),
   point: integer8("point").notNull().default(0),
-  deletedAt: timestamp50("deleted_at"),
-  createdAt: timestamp50("created_at").notNull().defaultNow(),
-  updatedAt: timestamp50("updated_at").notNull().defaultNow()
+  deletedAt: timestamp53("deleted_at"),
+  createdAt: timestamp53("created_at").notNull().defaultNow(),
+  updatedAt: timestamp53("updated_at").notNull().defaultNow()
 });
 
 // voting/nominee-vote.schema.ts
-import { pgTable as pgTable52, text as text50, timestamp as timestamp51 } from "drizzle-orm/pg-core";
-var nomineeVotes = pgTable52("nominee_votes", {
-  id: text50("id").primaryKey(),
-  userId: text50("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+import { pgTable as pgTable55, text as text53, timestamp as timestamp54 } from "drizzle-orm/pg-core";
+var nomineeVotes = pgTable55("nominee_votes", {
+  id: text53("id").primaryKey(),
+  userId: text53("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
   type: nomineeTypeEnum("type").notNull(),
-  firstChoiceNomineeId: text50("first_choice_nominee_id").notNull().references(() => nominees.id, { onDelete: "cascade" }),
-  secondChoiceNomineeId: text50("second_choice_nominee_id").notNull().references(() => nominees.id, { onDelete: "cascade" }),
-  thirdChoiceNomineeId: text50("third_choice_nominee_id").notNull().references(() => nominees.id, { onDelete: "cascade" }),
-  createdAt: timestamp51("created_at").notNull().defaultNow(),
-  updatedAt: timestamp51("updated_at").notNull().defaultNow()
+  firstChoiceNomineeId: text53("first_choice_nominee_id").notNull().references(() => nominees.id, { onDelete: "cascade" }),
+  secondChoiceNomineeId: text53("second_choice_nominee_id").notNull().references(() => nominees.id, { onDelete: "cascade" }),
+  thirdChoiceNomineeId: text53("third_choice_nominee_id").notNull().references(() => nominees.id, { onDelete: "cascade" }),
+  createdAt: timestamp54("created_at").notNull().defaultNow(),
+  updatedAt: timestamp54("updated_at").notNull().defaultNow()
 });
 
 // voting/project.schema.ts
-import { integer as integer9, pgTable as pgTable53, text as text51, timestamp as timestamp52 } from "drizzle-orm/pg-core";
-var projects = pgTable53("projects", {
-  id: text51("id").primaryKey(),
-  name: text51("name").notNull(),
-  type: nomineeTypeEnum("type").notNull(),
-  imageUrl: text51("image_url"),
-  description: text51("description"),
-  youtubeUrl: text51("youtube_url"),
-  teamName: text51("team_name").notNull(),
-  votes: integer9("votes").notNull().default(0),
-  deletedAt: timestamp52("deleted_at"),
-  createdAt: timestamp52("created_at").notNull().defaultNow(),
-  updatedAt: timestamp52("updated_at").notNull().defaultNow()
-});
+import { integer as integer9, pgTable as pgTable56, text as text54, timestamp as timestamp55, uniqueIndex as uniqueIndex4 } from "drizzle-orm/pg-core";
+var projects = pgTable56(
+  "projects",
+  {
+    id: text54("id").primaryKey(),
+    slug: text54("slug").notNull().unique(),
+    name: text54("name").notNull(),
+    type: nomineeTypeEnum("type").notNull(),
+    imageUrl: text54("image_url"),
+    description: text54("description"),
+    youtubeUrl: text54("youtube_url"),
+    externalUrl: text54("external_url"),
+    teamName: text54("team_name").notNull(),
+    votes: integer9("votes").notNull().default(0),
+    deletedAt: timestamp55("deleted_at"),
+    createdAt: timestamp55("created_at").notNull().defaultNow(),
+    updatedAt: timestamp55("updated_at").notNull().defaultNow()
+  },
+  (table) => [uniqueIndex4("projects_type_name_unique").on(table.type, table.name)]
+);
+
+// voting/project-vote.schema.ts
+import { index as index38, pgTable as pgTable57, text as text55, timestamp as timestamp56, uniqueIndex as uniqueIndex5 } from "drizzle-orm/pg-core";
+var projectVotes = pgTable57(
+  "project_votes",
+  {
+    id: text55("id").primaryKey(),
+    userId: text55("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    projectId: text55("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    type: nomineeTypeEnum("type").notNull(),
+    createdAt: timestamp56("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex5("project_votes_user_project_unique").on(table.userId, table.projectId),
+    index38("project_votes_user_type_idx").on(table.userId, table.type),
+    index38("project_votes_project_idx").on(table.projectId)
+  ]
+);
 
 // booth/exhibitor.schema.ts
-import { index as index36, pgTable as pgTable54, text as text52, timestamp as timestamp53 } from "drizzle-orm/pg-core";
-var exhibitors = pgTable54(
+import { index as index39, pgTable as pgTable58, text as text56, timestamp as timestamp57 } from "drizzle-orm/pg-core";
+var exhibitors = pgTable58(
   "exhibitors",
   {
-    id: text52("id").primaryKey(),
-    companyName: text52("company_name").notNull(),
-    name: text52("name").notNull(),
-    email: text52("email").notNull(),
-    phoneNumber: text52("phone_number").notNull(),
-    deletedAt: timestamp53("deleted_at"),
-    createdAt: timestamp53("created_at").notNull().defaultNow(),
-    updatedAt: timestamp53("updated_at").notNull().defaultNow()
+    id: text56("id").primaryKey(),
+    companyName: text56("company_name").notNull(),
+    name: text56("name").notNull(),
+    email: text56("email").notNull(),
+    phoneNumber: text56("phone_number").notNull(),
+    deletedAt: timestamp57("deleted_at"),
+    createdAt: timestamp57("created_at").notNull().defaultNow(),
+    updatedAt: timestamp57("updated_at").notNull().defaultNow()
   },
   (table) => [
-    index36("exhibitors_company_name_idx").on(table.companyName),
-    index36("exhibitors_email_idx").on(table.email)
+    index39("exhibitors_company_name_idx").on(table.companyName),
+    index39("exhibitors_email_idx").on(table.email)
   ]
 );
 
 // booth/main-event-booth-reward.schema.ts
-import { index as index37, integer as integer10, pgTable as pgTable55, text as text53, timestamp as timestamp54 } from "drizzle-orm/pg-core";
-var mainEventBoothRewards = pgTable55(
+import { index as index40, integer as integer10, pgTable as pgTable59, text as text57, timestamp as timestamp58 } from "drizzle-orm/pg-core";
+var mainEventBoothRewards = pgTable59(
   "main_event_booth_rewards",
   {
-    id: text53("id").primaryKey(),
-    companyName: text53("company_name").notNull(),
-    description: text53("description").notNull(),
+    id: text57("id").primaryKey(),
+    companyName: text57("company_name").notNull(),
+    description: text57("description").notNull(),
     points: integer10("points").notNull(),
     type: boothRewardTypeEnum("type").notNull(),
-    createdAt: timestamp54("created_at").notNull().defaultNow(),
-    updatedAt: timestamp54("updated_at").notNull().defaultNow()
+    createdAt: timestamp58("created_at").notNull().defaultNow(),
+    updatedAt: timestamp58("updated_at").notNull().defaultNow()
   },
   (table) => [
-    index37("main_event_booth_rewards_company_name_idx").on(table.companyName),
-    index37("main_event_booth_rewards_type_idx").on(table.type)
+    index40("main_event_booth_rewards_company_name_idx").on(table.companyName),
+    index40("main_event_booth_rewards_type_idx").on(table.type)
   ]
 );
 
 // supermarket/supermarket-item.schema.ts
-import { decimal, integer as integer11, pgTable as pgTable56, text as text54, timestamp as timestamp55 } from "drizzle-orm/pg-core";
-var supermarketItems = pgTable56("supermarket_items", {
-  id: text54("id").primaryKey(),
-  name: text54("name").notNull(),
-  description: text54("description"),
+import { decimal, integer as integer11, pgTable as pgTable60, text as text58, timestamp as timestamp59 } from "drizzle-orm/pg-core";
+var supermarketItems = pgTable60("supermarket_items", {
+  id: text58("id").primaryKey(),
+  name: text58("name").notNull(),
+  description: text58("description"),
   price: decimal("price", { precision: 10, scale: 2 }).notNull(),
   stock: integer11("stock").notNull().default(0),
-  category: text54("category").notNull(),
-  imageUrl: text54("image_url"),
-  deletedAt: timestamp55("deleted_at"),
+  category: text58("category").notNull(),
+  imageUrl: text58("image_url"),
+  deletedAt: timestamp59("deleted_at"),
   // Soft delete
-  createdAt: timestamp55("created_at").notNull().defaultNow(),
-  updatedAt: timestamp55("updated_at").notNull().defaultNow()
+  createdAt: timestamp59("created_at").notNull().defaultNow(),
+  updatedAt: timestamp59("updated_at").notNull().defaultNow()
 });
 
 // supermarket/supermarket-item-option.schema.ts
-import { relations as relations42 } from "drizzle-orm";
-import { pgTable as pgTable57, text as text55, timestamp as timestamp56 } from "drizzle-orm/pg-core";
-var supermarketItemOptions = pgTable57("supermarket_item_options", {
-  id: text55("id").primaryKey(),
-  itemId: text55("item_id").notNull().references(() => supermarketItems.id, { onDelete: "cascade" }),
-  key: text55("key").notNull(),
-  value: text55("value").notNull(),
-  deletedAt: timestamp56("deleted_at"),
+import { relations as relations44 } from "drizzle-orm";
+import { pgTable as pgTable61, text as text59, timestamp as timestamp60 } from "drizzle-orm/pg-core";
+var supermarketItemOptions = pgTable61("supermarket_item_options", {
+  id: text59("id").primaryKey(),
+  itemId: text59("item_id").notNull().references(() => supermarketItems.id, { onDelete: "cascade" }),
+  key: text59("key").notNull(),
+  value: text59("value").notNull(),
+  deletedAt: timestamp60("deleted_at"),
   // Soft delete
-  createdAt: timestamp56("created_at").notNull().defaultNow(),
-  updatedAt: timestamp56("updated_at").notNull().defaultNow()
+  createdAt: timestamp60("created_at").notNull().defaultNow(),
+  updatedAt: timestamp60("updated_at").notNull().defaultNow()
 });
-var supermarketItemOptionsRelations = relations42(supermarketItemOptions, ({ one }) => ({
+var supermarketItemOptionsRelations = relations44(supermarketItemOptions, ({ one }) => ({
   item: one(supermarketItems, {
     fields: [supermarketItemOptions.itemId],
     references: [supermarketItems.id]
@@ -1521,25 +1645,25 @@ var supermarketItemOptionsRelations = relations42(supermarketItemOptions, ({ one
 }));
 
 // supermarket/supermarket-user-cart.schema.ts
-import { relations as relations44 } from "drizzle-orm";
-import { decimal as decimal2, pgTable as pgTable59, text as text57, timestamp as timestamp58 } from "drizzle-orm/pg-core";
+import { relations as relations46 } from "drizzle-orm";
+import { decimal as decimal2, pgTable as pgTable63, text as text61, timestamp as timestamp62 } from "drizzle-orm/pg-core";
 
 // supermarket/supermarket-user-cart-item.schema.ts
-import { relations as relations43 } from "drizzle-orm";
-import { integer as integer12, json as json3, pgTable as pgTable58, text as text56, timestamp as timestamp57 } from "drizzle-orm/pg-core";
-var supermarketUserCartItems = pgTable58("supermarket_user_cart_items", {
-  id: text56("id").primaryKey(),
-  cartId: text56("cart_id").notNull().references(() => supermarketUserCarts.id, { onDelete: "cascade" }),
-  itemId: text56("item_id").notNull().references(() => supermarketItems.id, { onDelete: "cascade" }),
+import { relations as relations45 } from "drizzle-orm";
+import { integer as integer12, json as json3, pgTable as pgTable62, text as text60, timestamp as timestamp61 } from "drizzle-orm/pg-core";
+var supermarketUserCartItems = pgTable62("supermarket_user_cart_items", {
+  id: text60("id").primaryKey(),
+  cartId: text60("cart_id").notNull().references(() => supermarketUserCarts.id, { onDelete: "cascade" }),
+  itemId: text60("item_id").notNull().references(() => supermarketItems.id, { onDelete: "cascade" }),
   quantity: integer12("quantity").notNull().default(1),
   selectedOptions: json3("selected_options"),
   // JSON to store selected option key-value pairs
-  deletedAt: timestamp57("deleted_at"),
+  deletedAt: timestamp61("deleted_at"),
   // Soft delete
-  createdAt: timestamp57("created_at").notNull().defaultNow(),
-  updatedAt: timestamp57("updated_at").notNull().defaultNow()
+  createdAt: timestamp61("created_at").notNull().defaultNow(),
+  updatedAt: timestamp61("updated_at").notNull().defaultNow()
 });
-var supermarketUserCartItemsRelations = relations43(supermarketUserCartItems, ({ one }) => ({
+var supermarketUserCartItemsRelations = relations45(supermarketUserCartItems, ({ one }) => ({
   cart: one(supermarketUserCarts, {
     fields: [supermarketUserCartItems.cartId],
     references: [supermarketUserCarts.id]
@@ -1551,82 +1675,82 @@ var supermarketUserCartItemsRelations = relations43(supermarketUserCartItems, ({
 }));
 
 // supermarket/supermarket-user-cart.schema.ts
-var supermarketUserCarts = pgTable59("supermarket_user_carts", {
-  id: text57("id").primaryKey(),
-  userId: text57("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+var supermarketUserCarts = pgTable63("supermarket_user_carts", {
+  id: text61("id").primaryKey(),
+  userId: text61("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
   totalPrice: decimal2("total_price", { precision: 10, scale: 2 }).notNull(),
   status: cartStatusEnum("status").notNull().default("PENDING"),
-  deletedAt: timestamp58("deleted_at"),
+  deletedAt: timestamp62("deleted_at"),
   // Soft delete
-  createdAt: timestamp58("created_at").notNull().defaultNow(),
-  updatedAt: timestamp58("updated_at").notNull().defaultNow()
+  createdAt: timestamp62("created_at").notNull().defaultNow(),
+  updatedAt: timestamp62("updated_at").notNull().defaultNow()
 });
-var supermarketUserCartsRelations = relations44(supermarketUserCarts, ({ many }) => ({
+var supermarketUserCartsRelations = relations46(supermarketUserCarts, ({ many }) => ({
   cartItems: many(supermarketUserCartItems)
 }));
 
 // content/article.schema.ts
-import { pgTable as pgTable60, text as text58, timestamp as timestamp59 } from "drizzle-orm/pg-core";
-var articles = pgTable60("articles", {
-  id: text58("id").primaryKey(),
-  title: text58("title").notNull(),
-  description: text58("description"),
-  url: text58("url").notNull(),
-  imageUrl: text58("image_url"),
-  deletedAt: timestamp59("deleted_at"),
-  createdAt: timestamp59("created_at").notNull().defaultNow(),
-  updatedAt: timestamp59("updated_at").notNull().defaultNow()
+import { pgTable as pgTable64, text as text62, timestamp as timestamp63 } from "drizzle-orm/pg-core";
+var articles = pgTable64("articles", {
+  id: text62("id").primaryKey(),
+  title: text62("title").notNull(),
+  description: text62("description"),
+  url: text62("url").notNull(),
+  imageUrl: text62("image_url"),
+  deletedAt: timestamp63("deleted_at"),
+  createdAt: timestamp63("created_at").notNull().defaultNow(),
+  updatedAt: timestamp63("updated_at").notNull().defaultNow()
 });
 
 // content/explore-it-funfact.schema.ts
-import { pgTable as pgTable61, text as text59, timestamp as timestamp60 } from "drizzle-orm/pg-core";
-var exploreITFunfacts = pgTable61("explore_it_funfacts", {
-  id: text59("id").primaryKey(),
-  title: text59("title").notNull(),
-  content: text59("content").notNull(),
-  imageUrl: text59("image_url"),
-  deletedAt: timestamp60("deleted_at"),
-  createdAt: timestamp60("created_at").notNull().defaultNow(),
-  updatedAt: timestamp60("updated_at").notNull().defaultNow()
+import { pgTable as pgTable65, text as text63, timestamp as timestamp64 } from "drizzle-orm/pg-core";
+var exploreITFunfacts = pgTable65("explore_it_funfacts", {
+  id: text63("id").primaryKey(),
+  title: text63("title").notNull(),
+  content: text63("content").notNull(),
+  imageUrl: text63("image_url"),
+  deletedAt: timestamp64("deleted_at"),
+  createdAt: timestamp64("created_at").notNull().defaultNow(),
+  updatedAt: timestamp64("updated_at").notNull().defaultNow()
 });
 
 // notifications/dashboard-notification.schema.ts
-import { boolean as boolean15, index as index38, pgTable as pgTable62, text as text60, timestamp as timestamp61 } from "drizzle-orm/pg-core";
-var dashboardNotifications = pgTable62(
+import { boolean as boolean17, index as index41, pgTable as pgTable66, text as text64, timestamp as timestamp65 } from "drizzle-orm/pg-core";
+var dashboardNotifications = pgTable66(
   "dashboard_notifications",
   {
-    id: text60("id").primaryKey(),
-    title: text60("title").notNull(),
-    content: text60("content").notNull(),
-    isPrivate: boolean15("is_private").notNull().default(false),
-    type: text60("type").notNull(),
+    id: text64("id").primaryKey(),
+    title: text64("title").notNull(),
+    content: text64("content").notNull(),
+    isPrivate: boolean17("is_private").notNull().default(false),
+    type: text64("type").notNull(),
     programCode: programCodeEnum("program_code"),
-    deletedAt: timestamp61("deleted_at"),
-    createdAt: timestamp61("created_at").notNull().defaultNow(),
-    updatedAt: timestamp61("updated_at").notNull().defaultNow()
+    deletedAt: timestamp65("deleted_at"),
+    createdAt: timestamp65("created_at").notNull().defaultNow(),
+    updatedAt: timestamp65("updated_at").notNull().defaultNow()
   },
-  (table) => [index38("dashboard_notifications_program_code_idx").on(table.programCode)]
+  (table) => [index41("dashboard_notifications_program_code_idx").on(table.programCode)]
 );
 
 // notifications/dashboard-notification-user-read.schema.ts
-import { relations as relations45 } from "drizzle-orm";
-import { boolean as boolean16, index as index39, pgTable as pgTable63, text as text61, timestamp as timestamp62 } from "drizzle-orm/pg-core";
-var dashboardNotificationUserReads = pgTable63(
+import { relations as relations47 } from "drizzle-orm";
+import { boolean as boolean18, index as index42, pgTable as pgTable67, text as text65, timestamp as timestamp66 } from "drizzle-orm/pg-core";
+var dashboardNotificationUserReads = pgTable67(
   "dashboard_notification_user_reads",
   {
-    id: text61("id").primaryKey(),
-    userId: text61("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    notificationId: text61("notification_id").notNull().references(() => dashboardNotifications.id, { onDelete: "cascade" }),
-    isOpened: boolean16("is_opened").notNull().default(false),
-    createdAt: timestamp62("created_at").notNull().defaultNow(),
-    updatedAt: timestamp62("updated_at").notNull().defaultNow()
+    id: text65("id").primaryKey(),
+    userId: text65("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    notificationId: text65("notification_id").notNull().references(() => dashboardNotifications.id, { onDelete: "cascade" }),
+    isOpened: boolean18("is_opened").notNull().default(false),
+    createdAt: timestamp66("created_at").notNull().defaultNow(),
+    updatedAt: timestamp66("updated_at").notNull().defaultNow()
   },
   (table) => [
-    index39("dashboard_notification_user_reads_user_id_idx").on(table.userId),
-    index39("dashboard_notification_user_reads_notification_id_idx").on(table.notificationId)
+    index42("dashboard_notification_user_reads_user_id_idx").on(table.userId),
+    index42("dashboard_notification_user_reads_notification_id_idx").on(table.notificationId)
   ]
 );
-var dashboardNotificationUserReadsRelations = relations45(
+var dashboardNotificationUserReadsRelations = relations47(
   dashboardNotificationUserReads,
   ({ one }) => ({
     user: one(users, {
@@ -1641,32 +1765,32 @@ var dashboardNotificationUserReadsRelations = relations45(
 );
 
 // post-example/comment.schema.ts
-import { pgTable as pgTable64, text as text62, uuid as uuid10 } from "drizzle-orm/pg-core";
-var comments = pgTable64("comments", {
+import { pgTable as pgTable68, text as text66, uuid as uuid10 } from "drizzle-orm/pg-core";
+var comments = pgTable68("comments", {
   id: uuid10("id").primaryKey(),
   postId: uuid10("post_id").notNull(),
-  content: text62("content").notNull(),
-  author: text62("author").notNull()
+  content: text66("content").notNull(),
+  author: text66("author").notNull()
 });
 
 // post-example/like.schema.ts
-import { pgTable as pgTable65, text as text63, uuid as uuid11 } from "drizzle-orm/pg-core";
-var likes = pgTable65("likes", {
+import { pgTable as pgTable69, text as text67, uuid as uuid11 } from "drizzle-orm/pg-core";
+var likes = pgTable69("likes", {
   id: uuid11("id").primaryKey(),
   postId: uuid11("post_id").notNull(),
-  userName: text63("user_name").notNull()
+  userName: text67("user_name").notNull()
 });
 
 // post-example/post.schema.ts
-import { pgTable as pgTable66, text as text64, timestamp as timestamp63, uuid as uuid12 } from "drizzle-orm/pg-core";
-var posts = pgTable66("posts", {
+import { pgTable as pgTable70, text as text68, timestamp as timestamp67, uuid as uuid12 } from "drizzle-orm/pg-core";
+var posts = pgTable70("posts", {
   id: uuid12("id").primaryKey(),
   // Primary Key UUID
-  title: text64("title").notNull(),
-  content: text64("content").notNull(),
-  author: text64("author").notNull(),
-  createdAt: timestamp63("created_at").defaultNow().notNull(),
-  updatedAt: timestamp63("updated_at").defaultNow().notNull()
+  title: text68("title").notNull(),
+  content: text68("content").notNull(),
+  author: text68("author").notNull(),
+  createdAt: timestamp67("created_at").defaultNow().notNull(),
+  updatedAt: timestamp67("updated_at").defaultNow().notNull()
 });
 export {
   adWatchHistories,
@@ -1683,6 +1807,9 @@ export {
   companyExhibitionVacancies,
   companyExhibitionVacanciesRelations,
   companyExhibitions,
+  competitionPaymentProofs,
+  competitionPaymentProofsRelations,
+  competitionShowcases,
   cvClinicClaims,
   cvClinicVouchers,
   dashboardNotificationUserReads,
@@ -1717,6 +1844,7 @@ export {
   grandLaunchingRegistrations,
   grandLaunchingRegistrationsRelations,
   interviewApplicantStatusEnum,
+  joinRequestStatusEnum,
   knowEventSourceEnum,
   leaderboardHistories,
   likes,
@@ -1763,6 +1891,7 @@ export {
   programTypeEnum,
   programs,
   programsRelations,
+  projectVotes,
   projects,
   questionTypeEnum,
   rewardTypeEnum,
@@ -1777,6 +1906,8 @@ export {
   supermarketUserCartItemsRelations,
   supermarketUserCarts,
   supermarketUserCartsRelations,
+  teamJoinRequests,
+  teamJoinRequestsRelations,
   teamStatusEnum,
   teams,
   teamsRelations,