rhythia-api 209.0.0 → 211.0.0

package/api/getBadgeLeaders.ts

@@ -0,0 +1,69 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    limit: z.number().min(1).max(100).optional().default(100),
+  }),
+  output: z.object({
+    leaderboard: z.array(
+      z.object({
+        id: z.number(),
+        display_name: z.string(),
+        avatar_url: z.string().nullable(),
+        special_badge_count: z.number(),
+        earned_badges: z.array(z.string()),
+        all_badges: z.any(), // JSON type
+      })
+    ),
+    total_count: z.number(),
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return handler({ limit: 100 });
+}
+
+export async function handler({
+  limit = 100,
+}: {
+  limit?: number;
+}): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  try {
+    const { data: leaderboard, error } = await supabase.rpc(
+      "get_badge_leaderboard",
+      {
+        p_limit: limit,
+      }
+    );
+
+    if (error) {
+      console.error("Badge leaderboard error:", error);
+      return NextResponse.json(
+        {
+          leaderboard: [],
+          total_count: 0,
+          error: "Failed to fetch badge leaderboard",
+        },
+        { status: 500 }
+      );
+    }
+
+    return NextResponse.json({
+      leaderboard: leaderboard || [],
+      total_count: leaderboard?.length || 0,
+    });
+  } catch (error) {
+    console.error("Badge leaderboard exception:", error);
+    return NextResponse.json(
+      {
+        leaderboard: [],
+        total_count: 0,
+        error: "Internal server error",
+      },
+      { status: 500 }
+    );
+  }
+}

package/api/getUserScores.ts

@@ -33,16 +33,16 @@ export const Schema = {
     reign: z
       .array(
         z.object({
-          id: z.number(), // Use z.number() for compatibility, or z.bigint() if supported
-          awarded_sp: z.number().nullable(), // Use z.number() for NUMERIC
-          created_at: z.string(), // Use z.string() for TIMESTAMP WITH TIME ZONE
+          id: z.number(),
+          awarded_sp: z.number().nullable(),
+          created_at: z.string(),
           misses: z.number().nullable(),
           mods: z.record(z.unknown()),
           passed: z.boolean().nullable(),
           songId: z.string().nullable(),
           speed: z.number().nullable(),
           spin: z.boolean(),
-          beatmapHash: z.string().nullable(), // Add beatmapHash to the schema
+          beatmapHash: z.string().nullable(),
           beatmapTitle: z.string().nullable(),
           difficulty: z.number().nullable(),
           beatmapNotes: z.number().optional().nullable(),
@@ -91,128 +91,29 @@ export async function handler(
   data: (typeof Schema)["input"]["_type"],
   req: Request
 ): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  if (data.limit > 100) {
-    return NextResponse.json({ error: "Limit breached" });
-  }
-  let { data: scores1, error: errorlast } = await supabase
-    .from("scores")
-    .select(
-      `
-      *,
-      beatmaps (
-        difficulty,
-        noteCount,
-        title
-      )
-    `
-    )
-    .eq("userId", data.id)
-    .eq("passed", true)
-    .order("created_at", { ascending: false })
-    .limit(data.limit);
-
-  let { data: scores2, error: errorsp } = await supabase
-    .from("scores")
-    .select(
-      `
-      *,
-      beatmaps (
-        difficulty,
-        noteCount,
-        title
-      )
-    `
-    )
-    .eq("userId", data.id)
-    .neq("awarded_sp", 0)
-    .eq("passed", true)
-    .order("awarded_sp", { ascending: false });
-
-  if (scores2 == null) return NextResponse.json({ error: "No scores" });
-
-  let spinScores = 0;
-  let totalScores = scores2.length;
-  let hashMap: Record<string, { awarded_sp: number; score: any }> = {};
-
-  for (const score of scores2) {
-    const { beatmapHash, awarded_sp, spin } = score;
-
-    if (!beatmapHash || !awarded_sp) continue;
-
-    if (score.spin) {
-      spinScores++;
-    }
-
-    if (!hashMap[beatmapHash] || hashMap[beatmapHash].awarded_sp < awarded_sp) {
-      hashMap[beatmapHash] = { awarded_sp, score };
+  // Call the RPC created earlier
+  const { data: result, error } = await supabase.rpc(
+    "get_user_scores_summary",
+    {
+      userid: data.id,
+      limit_param: data.limit,
     }
-  }
-
-  const values = Object.values(hashMap);
-  let vals = values
-    .sort((a, b) => b.awarded_sp - a.awarded_sp)
-    .slice(0, data.limit)
-    .map((e) => e.score);
-
-  const { data: reignScores, error } = await supabase.rpc(
-    "get_user_reigning_scores",
-    { userid: data.id, page_size: 10 }
   );
 
   if (error) {
     return NextResponse.json({ error: JSON.stringify(error) });
   }
 
-  return NextResponse.json({
-    lastDay: scores1?.map((s) => ({
-      created_at: s.created_at,
-      id: s.id,
-      passed: s.passed,
-      userId: s.userId,
-      awarded_sp: s.awarded_sp,
-      beatmapHash: s.beatmapHash,
-      misses: s.misses,
-      songId: s.songId,
-      beatmapDifficulty: s.beatmaps?.difficulty,
-      beatmapNotes: s.beatmaps?.noteCount,
-      beatmapTitle: s.beatmaps?.title,
-      speed: s.speed,
-      spin: s.spin,
-    })),
-    reign: reignScores?.map((s) => ({
-      id: s.id,
-      awarded_sp: s.awarded_sp,
-      created_at: s.created_at,
-      misses: s.misses,
-      mods: s.mods as any,
-      passed: s.passed,
-      songId: s.songid,
-      speed: s.speed,
-      spin: s.spin,
-      beatmapHash: s.beatmaphash,
-      beatmapTitle: s.beatmaptitle,
-      beatmapNotes: s.notes,
-      difficulty: s.difficulty,
-    })),
-    top: vals?.map((s) => ({
-      created_at: s.created_at,
-      id: s.id,
-      passed: s.passed,
-      userId: s.userId,
-      awarded_sp: s.awarded_sp,
-      beatmapHash: s.beatmapHash,
-      misses: s.misses,
-      rank: s.rank,
-      songId: s.songId,
-      beatmapDifficulty: s.beatmaps?.difficulty,
-      beatmapNotes: s.beatmaps?.noteCount,
-      beatmapTitle: s.beatmaps?.title,
-      speed: s.speed,
-      spin: s.spin,
-    })),
-    stats: {
-      totalScores,
-      spinScores,
-    },
-  });
+  if (!result) {
+    return NextResponse.json({ error: "No data returned" });
+  }
+
+  // The RPC may return { error: "..." } as a JSON object
+  if (typeof result === "object" && result !== null && "error" in result) {
+    return NextResponse.json({ error: String((result as any).error) });
+  }
+
+  // Trust the RPC's JSON shape to match Schema.output
+  const typedResult = result as (typeof Schema)["output"]["_type"];
+  return NextResponse.json(typedResult);
 }

package/api/submitScore.ts

@@ -279,6 +279,27 @@ export async function handler({
     squares_hit: (userData.squares_hit || 0) + data.hits,
   });
   console.log("p3");
+  // Grant special badges if applicable
+  if (passed && beatmapPages && !data.mods.includes("mod_nofail")) {
+    try {
+      const { data: badgeResult, error: badgeError } = await supabase.rpc(
+        "grant_special_badges",
+        {
+          p_user_id: userData.id,
+          p_beatmap_id: beatmapPages.id,
+          p_spin: data.spin || false,
+          p_passed: passed,
+        }
+      );
+
+      const result = badgeResult as { granted: boolean; badge: string | null };
+      if (result && result.granted) {
+        console.log(`Badge granted: ${result.badge} to user ${userData.id}`);
+      }
+    } catch (error) {
+      console.error("Error granting badge:", error);
+    }
+  }
 
   if (awarded_sp > 99 && userData.ban == "cool") {
     await postToWebhooks({

package/index.ts

@@ -370,6 +370,32 @@ import { Schema as GetBadgedUsers } from "./api/getBadgedUsers"
 export { Schema as SchemaGetBadgedUsers } from "./api/getBadgedUsers"
 export const getBadgedUsers = handleApi({url:"/api/getBadgedUsers",...GetBadgedUsers})
 
+// ./api/getBadgeLeaders.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    limit: z.number().min(1).max(100).optional().default(100),
+  }),
+  output: z.object({
+    leaderboard: z.array(
+      z.object({
+        id: z.number(),
+        display_name: z.string(),
+        avatar_url: z.string().nullable(),
+        special_badge_count: z.number(),
+        earned_badges: z.array(z.string()),
+        all_badges: z.any(), // JSON type
+      })
+    ),
+    total_count: z.number(),
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as GetBadgeLeaders } from "./api/getBadgeLeaders"
+export { Schema as SchemaGetBadgeLeaders } from "./api/getBadgeLeaders"
+export const getBadgeLeaders = handleApi({url:"/api/getBadgeLeaders",...GetBadgeLeaders})
+
 // ./api/getBeatmapComments.ts API
 
 /*
@@ -1079,16 +1105,16 @@ export const Schema = {
     reign: z
       .array(
         z.object({
-          id: z.number(), // Use z.number() for compatibility, or z.bigint() if supported
-          awarded_sp: z.number().nullable(), // Use z.number() for NUMERIC
-          created_at: z.string(), // Use z.string() for TIMESTAMP WITH TIME ZONE
+          id: z.number(),
+          awarded_sp: z.number().nullable(),
+          created_at: z.string(),
           misses: z.number().nullable(),
           mods: z.record(z.unknown()),
           passed: z.boolean().nullable(),
           songId: z.string().nullable(),
           speed: z.number().nullable(),
           spin: z.boolean(),
-          beatmapHash: z.string().nullable(), // Add beatmapHash to the schema
+          beatmapHash: z.string().nullable(),
           beatmapTitle: z.string().nullable(),
           difficulty: z.number().nullable(),
           beatmapNotes: z.number().optional().nullable(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "209.0.0",
+  "version": "211.0.0",
   "main": "index.ts",
   "author": "online-contributors-cunev",
   "scripts": {

package/types/database.ts

@@ -7,6 +7,11 @@ export type Json =
   | Json[]
 
 export type Database = {
+  // Allows to automatically instantiate createClient with right options
+  // instead of createClient<Database, { PostgrestVersion: 'XX' }>(URL, KEY)
+  __InternalSupabase: {
+    PostgrestVersion: "12.2.3 (519615d)"
+  }
   public: {
     Tables: {
       admin_actions: {
@@ -621,64 +626,47 @@ export type Database = {
     }
     Functions: {
       admin_delete_user: {
-        Args: {
-          user_id: number
-        }
+        Args: { user_id: number }
         Returns: boolean
       }
       admin_exclude_user: {
-        Args: {
-          user_id: number
-        }
+        Args: { user_id: number }
         Returns: boolean
       }
       admin_invalidate_ranked_scores: {
-        Args: {
-          user_id: number
-        }
+        Args: { user_id: number }
         Returns: number
       }
-      admin_log_action:
-        | {
-            Args: {
-              admin_id: number
+      admin_log_action: {
+        Args:
+          | {
               action_type: string
-              target_id: number
+              admin_id: number
               details?: Json
+              target_id: number
             }
-            Returns: undefined
-          }
-        | {
-            Args: {
-              admin_id: number
+          | {
               action_type: string
-              target_id: string
+              admin_id: number
               details?: Json
+              target_id: string
             }
-            Returns: undefined
-          }
+        Returns: undefined
+      }
       admin_profanity_clear: {
-        Args: {
-          user_id: number
-        }
+        Args: { user_id: number }
         Returns: boolean
       }
       admin_remove_all_scores: {
-        Args: {
-          user_id: number
-        }
+        Args: { user_id: number }
         Returns: number
       }
       admin_restrict_user: {
-        Args: {
-          user_id: number
-        }
+        Args: { user_id: number }
         Returns: boolean
       }
       admin_search_users: {
-        Args: {
-          search_text: string
-        }
+        Args: { search_text: string }
         Returns: {
           about_me: string | null
           avatar_url: string | null
@@ -705,46 +693,55 @@ export type Database = {
         }[]
       }
       admin_silence_user: {
-        Args: {
-          user_id: number
-        }
+        Args: { user_id: number }
         Returns: boolean
       }
       admin_unban_user: {
-        Args: {
-          user_id: number
-        }
+        Args: { user_id: number }
         Returns: boolean
       }
-      get_clan_leaderboard: {
-        Args: {
-          page_number?: number
-          items_per_page?: number
-        }
+      get_badge_leaderboard: {
+        Args: { p_limit?: number }
         Returns: {
+          all_badges: Json
+          avatar_url: string
+          display_name: string
+          earned_badges: string[]
           id: number
-          name: string
+          special_badge_count: number
+        }[]
+      }
+      get_clan_leaderboard: {
+        Args: { items_per_page?: number; page_number?: number }
+        Returns: {
           acronym: string
           avatar_url: string
           description: string
+          id: number
           member_count: number
-          total_skill_points: number
+          name: string
           total_pages: number
+          total_skill_points: number
         }[]
       }
       get_collections_v1: {
-        Args: {
-          page_number?: number
-          items_per_page?: number
-        }
+        Args: { items_per_page?: number; page_number?: number }
         Returns: {
-          id: number
-          title: string
-          description: string
+          beatmap_count: number
           created_at: string
+          description: string
+          id: number
           owner: number
-          beatmap_count: number
           star1: number
+          star10: number
+          star11: number
+          star12: number
+          star13: number
+          star14: number
+          star15: number
+          star16: number
+          star17: number
+          star18: number
           star2: number
           star3: number
           star4: number
@@ -753,6 +750,27 @@ export type Database = {
           star7: number
           star8: number
           star9: number
+          title: string
+          total_pages: number
+        }[]
+      }
+      get_collections_v2: {
+        Args:
+          | {
+              items_per_page?: number
+              owner_filter?: number
+              page_number?: number
+            }
+          | { items_per_page?: number; page_number?: number }
+        Returns: {
+          beatmap_count: number
+          created_at: string
+          description: string
+          id: number
+          owner: number
+          owner_avatar_url: string
+          owner_username: string
+          star1: number
           star10: number
           star11: number
           star12: number
@@ -762,105 +780,33 @@ export type Database = {
           star16: number
           star17: number
           star18: number
+          star2: number
+          star3: number
+          star4: number
+          star5: number
+          star6: number
+          star7: number
+          star8: number
+          star9: number
+          title: string
           total_pages: number
         }[]
       }
-      get_collections_v2:
-        | {
-            Args: {
-              page_number?: number
-              items_per_page?: number
-            }
-            Returns: {
-              id: number
-              title: string
-              description: string
-              created_at: string
-              owner: number
-              owner_username: string
-              owner_avatar_url: string
-              beatmap_count: number
-              star1: number
-              star2: number
-              star3: number
-              star4: number
-              star5: number
-              star6: number
-              star7: number
-              star8: number
-              star9: number
-              star10: number
-              star11: number
-              star12: number
-              star13: number
-              star14: number
-              star15: number
-              star16: number
-              star17: number
-              star18: number
-              total_pages: number
-            }[]
-          }
-        | {
-            Args: {
-              page_number?: number
-              items_per_page?: number
-              owner_filter?: number
-            }
-            Returns: {
-              id: number
-              title: string
-              description: string
-              created_at: string
-              owner: number
-              owner_username: string
-              owner_avatar_url: string
-              beatmap_count: number
-              star1: number
-              star2: number
-              star3: number
-              star4: number
-              star5: number
-              star6: number
-              star7: number
-              star8: number
-              star9: number
-              star10: number
-              star11: number
-              star12: number
-              star13: number
-              star14: number
-              star15: number
-              star16: number
-              star17: number
-              star18: number
-              total_pages: number
-            }[]
-          }
       get_collections_v3: {
         Args: {
-          page_number?: number
           items_per_page?: number
           owner_filter?: number
+          page_number?: number
         }
         Returns: {
-          id: number
-          title: string
-          description: string
+          beatmap_count: number
           created_at: string
+          description: string
+          id: number
           owner: number
-          owner_username: string
           owner_avatar_url: string
-          beatmap_count: number
+          owner_username: string
           star1: number
-          star2: number
-          star3: number
-          star4: number
-          star5: number
-          star6: number
-          star7: number
-          star8: number
-          star9: number
           star10: number
           star11: number
           star12: number
@@ -870,36 +816,36 @@ export type Database = {
           star16: number
           star17: number
           star18: number
+          star2: number
+          star3: number
+          star4: number
+          star5: number
+          star6: number
+          star7: number
+          star8: number
+          star9: number
+          title: string
           total_pages: number
         }[]
       }
       get_collections_v4: {
         Args: {
-          page_number?: number
+          author_filter?: string
           items_per_page?: number
+          min_beatmaps?: number
           owner_filter?: number
+          page_number?: number
           search_query?: string
-          author_filter?: string
-          min_beatmaps?: number
         }
         Returns: {
-          id: number
-          title: string
-          description: string
+          beatmap_count: number
           created_at: string
+          description: string
+          id: number
           owner: number
-          owner_username: string
           owner_avatar_url: string
-          beatmap_count: number
+          owner_username: string
           star1: number
-          star2: number
-          star3: number
-          star4: number
-          star5: number
-          star6: number
-          star7: number
-          star8: number
-          star9: number
           star10: number
           star11: number
           star12: number
@@ -909,17 +855,26 @@ export type Database = {
           star16: number
           star17: number
           star18: number
+          star2: number
+          star3: number
+          star4: number
+          star5: number
+          star6: number
+          star7: number
+          star8: number
+          star9: number
+          title: string
           total_pages: number
         }[]
       }
       get_top_scores_for_beatmap: {
-        Args: {
-          beatmap_hash: string
-        }
+        Args: { beatmap_hash: string }
         Returns: {
-          id: number
+          accuracy: number
+          avatar_url: string
           awarded_sp: number
           created_at: string
+          id: number
           misses: number
           mods: Json
           passed: boolean
@@ -929,18 +884,16 @@ export type Database = {
           spin: boolean
           userid: number
           username: string
-          avatar_url: string
-          accuracy: number
         }[]
       }
       get_top_scores_for_beatmap2: {
-        Args: {
-          beatmap_hash: string
-        }
+        Args: { beatmap_hash: string }
         Returns: {
-          id: number
+          accuracy: number
+          avatar_url: string
           awarded_sp: number
           created_at: string
+          id: number
           misses: number
           mods: Json
           passed: boolean
@@ -950,57 +903,48 @@ export type Database = {
           spin: boolean
           userid: number
           username: string
-          avatar_url: string
-          accuracy: number
         }[]
       }
+      get_user_activity: {
+        Args: { score_limit?: number; user_id: number }
+        Returns: Json
+      }
       get_user_by_email: {
+        Args: { email_address: string }
+        Returns: Json
+      }
+      get_user_reigning_scores: {
+        Args: { page_size: number; userid: number } | { userid: number }
+        Returns: {
+          awarded_sp: number
+          beatmaphash: string
+          beatmaptitle: string
+          created_at: string
+          difficulty: number
+          id: number
+          misses: number
+          mods: Json
+          notes: number
+          passed: boolean
+          replayhwid: string
+          songid: string
+          speed: number
+          spin: boolean
+        }[]
+      }
+      get_user_scores_summary: {
+        Args: { limit_param?: number; userid: number }
+        Returns: Json
+      }
+      grant_special_badges: {
         Args: {
-          email_address: string
+          p_beatmap_id: number
+          p_passed?: boolean
+          p_spin?: boolean
+          p_user_id: number
         }
         Returns: Json
       }
-      get_user_reigning_scores:
-        | {
-            Args: {
-              userid: number
-            }
-            Returns: {
-              id: number
-              awarded_sp: number
-              created_at: string
-              misses: number
-              mods: Json
-              passed: boolean
-              replayhwid: string
-              songid: string
-              speed: number
-              spin: boolean
-              beatmaphash: string
-            }[]
-          }
-        | {
-            Args: {
-              userid: number
-              page_size: number
-            }
-            Returns: {
-              id: number
-              awarded_sp: number
-              created_at: string
-              misses: number
-              mods: Json
-              passed: boolean
-              replayhwid: string
-              songid: string
-              speed: number
-              spin: boolean
-              beatmaphash: string
-              beatmaptitle: string
-              difficulty: number
-              notes: number
-            }[]
-          }
     }
     Enums: {
       banTypes: "cool" | "silenced" | "restricted" | "excluded"
@@ -1012,27 +956,33 @@ export type Database = {
   }
 }
 
-type PublicSchema = Database[Extract<keyof Database, "public">]
+type DatabaseWithoutInternals = Omit<Database, "__InternalSupabase">
+
+type DefaultSchema = DatabaseWithoutInternals[Extract<keyof Database, "public">]
 
 export type Tables<
-  PublicTableNameOrOptions extends
-    | keyof (PublicSchema["Tables"] & PublicSchema["Views"])
-    | { schema: keyof Database },
-  TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
-    ? keyof (Database[PublicTableNameOrOptions["schema"]]["Tables"] &
-        Database[PublicTableNameOrOptions["schema"]]["Views"])
+  DefaultSchemaTableNameOrOptions extends
+    | keyof (DefaultSchema["Tables"] & DefaultSchema["Views"])
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof (DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"] &
+        DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Views"])
     : never = never,
-> = PublicTableNameOrOptions extends { schema: keyof Database }
-  ? (Database[PublicTableNameOrOptions["schema"]]["Tables"] &
-      Database[PublicTableNameOrOptions["schema"]]["Views"])[TableName] extends {
+> = DefaultSchemaTableNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? (DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"] &
+      DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Views"])[TableName] extends {
       Row: infer R
     }
     ? R
     : never
-  : PublicTableNameOrOptions extends keyof (PublicSchema["Tables"] &
-        PublicSchema["Views"])
-    ? (PublicSchema["Tables"] &
-        PublicSchema["Views"])[PublicTableNameOrOptions] extends {
+  : DefaultSchemaTableNameOrOptions extends keyof (DefaultSchema["Tables"] &
+        DefaultSchema["Views"])
+    ? (DefaultSchema["Tables"] &
+        DefaultSchema["Views"])[DefaultSchemaTableNameOrOptions] extends {
         Row: infer R
       }
       ? R
@@ -1040,20 +990,24 @@ export type Tables<
     : never
 
 export type TablesInsert<
-  PublicTableNameOrOptions extends
-    | keyof PublicSchema["Tables"]
-    | { schema: keyof Database },
-  TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
-    ? keyof Database[PublicTableNameOrOptions["schema"]]["Tables"]
+  DefaultSchemaTableNameOrOptions extends
+    | keyof DefaultSchema["Tables"]
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"]
     : never = never,
-> = PublicTableNameOrOptions extends { schema: keyof Database }
-  ? Database[PublicTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+> = DefaultSchemaTableNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"][TableName] extends {
       Insert: infer I
     }
     ? I
     : never
-  : PublicTableNameOrOptions extends keyof PublicSchema["Tables"]
-    ? PublicSchema["Tables"][PublicTableNameOrOptions] extends {
+  : DefaultSchemaTableNameOrOptions extends keyof DefaultSchema["Tables"]
+    ? DefaultSchema["Tables"][DefaultSchemaTableNameOrOptions] extends {
         Insert: infer I
       }
       ? I
@@ -1061,20 +1015,24 @@ export type TablesInsert<
     : never
 
 export type TablesUpdate<
-  PublicTableNameOrOptions extends
-    | keyof PublicSchema["Tables"]
-    | { schema: keyof Database },
-  TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
-    ? keyof Database[PublicTableNameOrOptions["schema"]]["Tables"]
+  DefaultSchemaTableNameOrOptions extends
+    | keyof DefaultSchema["Tables"]
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"]
     : never = never,
-> = PublicTableNameOrOptions extends { schema: keyof Database }
-  ? Database[PublicTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+> = DefaultSchemaTableNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"][TableName] extends {
       Update: infer U
     }
     ? U
     : never
-  : PublicTableNameOrOptions extends keyof PublicSchema["Tables"]
-    ? PublicSchema["Tables"][PublicTableNameOrOptions] extends {
+  : DefaultSchemaTableNameOrOptions extends keyof DefaultSchema["Tables"]
+    ? DefaultSchema["Tables"][DefaultSchemaTableNameOrOptions] extends {
         Update: infer U
       }
       ? U
@@ -1082,29 +1040,44 @@ export type TablesUpdate<
     : never
 
 export type Enums<
-  PublicEnumNameOrOptions extends
-    | keyof PublicSchema["Enums"]
-    | { schema: keyof Database },
-  EnumName extends PublicEnumNameOrOptions extends { schema: keyof Database }
-    ? keyof Database[PublicEnumNameOrOptions["schema"]]["Enums"]
+  DefaultSchemaEnumNameOrOptions extends
+    | keyof DefaultSchema["Enums"]
+    | { schema: keyof DatabaseWithoutInternals },
+  EnumName extends DefaultSchemaEnumNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"]
     : never = never,
-> = PublicEnumNameOrOptions extends { schema: keyof Database }
-  ? Database[PublicEnumNameOrOptions["schema"]]["Enums"][EnumName]
-  : PublicEnumNameOrOptions extends keyof PublicSchema["Enums"]
-    ? PublicSchema["Enums"][PublicEnumNameOrOptions]
+> = DefaultSchemaEnumNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? DatabaseWithoutInternals[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"][EnumName]
+  : DefaultSchemaEnumNameOrOptions extends keyof DefaultSchema["Enums"]
+    ? DefaultSchema["Enums"][DefaultSchemaEnumNameOrOptions]
     : never
 
 export type CompositeTypes<
   PublicCompositeTypeNameOrOptions extends
-    | keyof PublicSchema["CompositeTypes"]
-    | { schema: keyof Database },
+    | keyof DefaultSchema["CompositeTypes"]
+    | { schema: keyof DatabaseWithoutInternals },
   CompositeTypeName extends PublicCompositeTypeNameOrOptions extends {
-    schema: keyof Database
+    schema: keyof DatabaseWithoutInternals
   }
-    ? keyof Database[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"]
+    ? keyof DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"]
     : never = never,
-> = PublicCompositeTypeNameOrOptions extends { schema: keyof Database }
-  ? Database[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"][CompositeTypeName]
-  : PublicCompositeTypeNameOrOptions extends keyof PublicSchema["CompositeTypes"]
-    ? PublicSchema["CompositeTypes"][PublicCompositeTypeNameOrOptions]
+> = PublicCompositeTypeNameOrOptions extends {
+  schema: keyof DatabaseWithoutInternals
+}
+  ? DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"][CompositeTypeName]
+  : PublicCompositeTypeNameOrOptions extends keyof DefaultSchema["CompositeTypes"]
+    ? DefaultSchema["CompositeTypes"][PublicCompositeTypeNameOrOptions]
     : never
+
+export const Constants = {
+  public: {
+    Enums: {
+      banTypes: ["cool", "silenced", "restricted", "excluded"],
+      discordWebhookType: ["maps", "scores"],
+    },
+  },
+} as const