@playcademy/sdk 0.0.4 → 0.0.6

package/dist/index.d.ts

@@ -1,10 +1,4001 @@
+import * as _playcademy_realtime_server_types from '@playcademy/realtime/server/types';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import * as drizzle_zod from 'drizzle-zod';
+import { z } from 'zod';
+
 /**
- * @fileoverview Playcademy SDK - Main Entry Point
+ * SDK Constants
+ * These are re-exported from @playcademy/data but defined here
+ * to avoid bundling issues with API Extractor
+ */
+declare const CURRENCIES: {
+    readonly PRIMARY: "PLAYCADEMY_CREDITS";
+    readonly XP: "PLAYCADEMY_XP";
+};
+declare const BADGES: {
+    readonly FOUNDING_MEMBER: "FOUNDING_MEMBER_BADGE";
+    readonly EARLY_ADOPTER: "EARLY_ADOPTER_BADGE";
+    readonly FIRST_GAME: "FIRST_GAME_BADGE";
+};
+declare const AuthProvider: {
+    readonly TIMEBACK: "TIMEBACK";
+};
+
+declare const users: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "user";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: drizzle_orm_pg_core.PgColumn<{
+            name: "name";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        username: drizzle_orm_pg_core.PgColumn<{
+            name: "username";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        email: drizzle_orm_pg_core.PgColumn<{
+            name: "email";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        timebackId: drizzle_orm_pg_core.PgColumn<{
+            name: "timeback_id";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        emailVerified: drizzle_orm_pg_core.PgColumn<{
+            name: "email_verified";
+            tableName: "user";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        image: drizzle_orm_pg_core.PgColumn<{
+            name: "image";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: drizzle_orm_pg_core.PgColumn<{
+            name: "role";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "admin" | "player" | "developer";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["admin", "player", "developer"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        developerStatus: drizzle_orm_pg_core.PgColumn<{
+            name: "developer_status";
+            tableName: "user";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "none" | "pending" | "approved";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["none", "pending", "approved"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        characterCreated: drizzle_orm_pg_core.PgColumn<{
+            name: "character_created";
+            tableName: "user";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "user";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "user";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+
+type GameMetadata = {
+    description?: string;
+    emoji?: string;
+    [key: string]: unknown;
+};
+declare const games: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "games";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        developerId: drizzle_orm_pg_core.PgColumn<{
+            name: "developer_id";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        slug: drizzle_orm_pg_core.PgColumn<{
+            name: "slug";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        displayName: drizzle_orm_pg_core.PgColumn<{
+            name: "display_name";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        version: drizzle_orm_pg_core.PgColumn<{
+            name: "version";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 50;
+        }>;
+        gameType: drizzle_orm_pg_core.PgColumn<{
+            name: "game_type";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "hosted" | "external";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["hosted", "external"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        assetBundleBase: drizzle_orm_pg_core.PgColumn<{
+            name: "asset_bundle_base";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        externalUrl: drizzle_orm_pg_core.PgColumn<{
+            name: "external_url";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        platform: drizzle_orm_pg_core.PgColumn<{
+            name: "platform";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "web" | "godot" | "unity";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["web", "godot", "unity"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mapElementId: drizzle_orm_pg_core.PgColumn<{
+            name: "map_element_id";
+            tableName: "games";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "games";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: GameMetadata;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: GameMetadata;
+        }>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "games";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "games";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const items: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "items";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        slug: drizzle_orm_pg_core.PgColumn<{
+            name: "slug";
+            tableName: "items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        gameId: drizzle_orm_pg_core.PgColumn<{
+            name: "game_id";
+            tableName: "items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        displayName: drizzle_orm_pg_core.PgColumn<{
+            name: "display_name";
+            tableName: "items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: drizzle_orm_pg_core.PgColumn<{
+            name: "description";
+            tableName: "items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: drizzle_orm_pg_core.PgColumn<{
+            name: "type";
+            tableName: "items";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "accessory" | "other";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["currency", "badge", "trophy", "collectible", "consumable", "unlock", "upgrade", "accessory", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isPlaceable: drizzle_orm_pg_core.PgColumn<{
+            name: "is_placeable";
+            tableName: "items";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        imageUrl: drizzle_orm_pg_core.PgColumn<{
+            name: "image_url";
+            tableName: "items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "items";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "items";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const inventoryItems: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "inventory_items";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "inventory_items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "user_id";
+            tableName: "inventory_items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        itemId: drizzle_orm_pg_core.PgColumn<{
+            name: "item_id";
+            tableName: "inventory_items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        quantity: drizzle_orm_pg_core.PgColumn<{
+            name: "quantity";
+            tableName: "inventory_items";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "inventory_items";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const shopListings: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "shop_listings";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "shop_listings";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        itemId: drizzle_orm_pg_core.PgColumn<{
+            name: "item_id";
+            tableName: "shop_listings";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currencyId: drizzle_orm_pg_core.PgColumn<{
+            name: "currency_id";
+            tableName: "shop_listings";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        price: drizzle_orm_pg_core.PgColumn<{
+            name: "price";
+            tableName: "shop_listings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sellBackPercentage: drizzle_orm_pg_core.PgColumn<{
+            name: "sell_back_percentage";
+            tableName: "shop_listings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stock: drizzle_orm_pg_core.PgColumn<{
+            name: "stock";
+            tableName: "shop_listings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isActive: drizzle_orm_pg_core.PgColumn<{
+            name: "is_active";
+            tableName: "shop_listings";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        availableFrom: drizzle_orm_pg_core.PgColumn<{
+            name: "available_from";
+            tableName: "shop_listings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        availableUntil: drizzle_orm_pg_core.PgColumn<{
+            name: "available_until";
+            tableName: "shop_listings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "shop_listings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "shop_listings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const mapElements: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "map_elements";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "map_elements";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mapId: drizzle_orm_pg_core.PgColumn<{
+            name: "map_id";
+            tableName: "map_elements";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        elementSlug: drizzle_orm_pg_core.PgColumn<{
+            name: "element_slug";
+            tableName: "map_elements";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        interactionType: drizzle_orm_pg_core.PgColumn<{
+            name: "interaction_type";
+            tableName: "map_elements";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "game_entry" | "game_registry" | "info" | "teleport" | "door_in" | "door_out" | "npc_interaction" | "quest_trigger";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["game_entry", "game_registry", "info", "teleport", "door_in", "door_out", "npc_interaction", "quest_trigger"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        gameId: drizzle_orm_pg_core.PgColumn<{
+            name: "game_id";
+            tableName: "map_elements";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "map_elements";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+declare const mapObjects: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "map_objects";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "map_objects";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "user_id";
+            tableName: "map_objects";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mapId: drizzle_orm_pg_core.PgColumn<{
+            name: "map_id";
+            tableName: "map_objects";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        itemId: drizzle_orm_pg_core.PgColumn<{
+            name: "item_id";
+            tableName: "map_objects";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        worldX: drizzle_orm_pg_core.PgColumn<{
+            name: "world_x";
+            tableName: "map_objects";
+            dataType: "number";
+            columnType: "PgDoublePrecision";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        worldY: drizzle_orm_pg_core.PgColumn<{
+            name: "world_y";
+            tableName: "map_objects";
+            dataType: "number";
+            columnType: "PgDoublePrecision";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rotation: drizzle_orm_pg_core.PgColumn<{
+            name: "rotation";
+            tableName: "map_objects";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scale: drizzle_orm_pg_core.PgColumn<{
+            name: "scale";
+            tableName: "map_objects";
+            dataType: "number";
+            columnType: "PgDoublePrecision";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "map_objects";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+
+declare const userLevels: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "user_levels";
+    schema: undefined;
+    columns: {
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "user_id";
+            tableName: "user_levels";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currentLevel: drizzle_orm_pg_core.PgColumn<{
+            name: "current_level";
+            tableName: "user_levels";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currentXp: drizzle_orm_pg_core.PgColumn<{
+            name: "current_xp";
+            tableName: "user_levels";
+            dataType: "number";
+            columnType: "PgDoublePrecision";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        totalXP: drizzle_orm_pg_core.PgColumn<{
+            name: "total_xp";
+            tableName: "user_levels";
+            dataType: "number";
+            columnType: "PgDoublePrecision";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastLevelUpAt: drizzle_orm_pg_core.PgColumn<{
+            name: "last_level_up_at";
+            tableName: "user_levels";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "user_levels";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "user_levels";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const levelConfigs: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "level_configs";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "level_configs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        level: drizzle_orm_pg_core.PgColumn<{
+            name: "level";
+            tableName: "level_configs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        xpRequired: drizzle_orm_pg_core.PgColumn<{
+            name: "xp_required";
+            tableName: "level_configs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        creditsReward: drizzle_orm_pg_core.PgColumn<{
+            name: "credits_reward";
+            tableName: "level_configs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "level_configs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const characterComponents: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "character_components";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "character_components";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        componentType: drizzle_orm_pg_core.PgColumn<{
+            name: "component_type";
+            tableName: "character_components";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "accessory" | "body" | "outfit" | "hairstyle" | "eyes";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["body", "outfit", "hairstyle", "eyes", "accessory"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        slug: drizzle_orm_pg_core.PgColumn<{
+            name: "slug";
+            tableName: "character_components";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 128;
+        }>;
+        displayName: drizzle_orm_pg_core.PgColumn<{
+            name: "display_name";
+            tableName: "character_components";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 128;
+        }>;
+        slot: drizzle_orm_pg_core.PgColumn<{
+            name: "slot";
+            tableName: "character_components";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 64;
+        }>;
+        spriteSheetId: drizzle_orm_pg_core.PgColumn<{
+            name: "sprite_sheet_id";
+            tableName: "character_components";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        unlockLevel: drizzle_orm_pg_core.PgColumn<{
+            name: "unlock_level";
+            tableName: "character_components";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        variant: drizzle_orm_pg_core.PgColumn<{
+            name: "variant";
+            tableName: "character_components";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "character_components";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "character_components";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const playerCharacters: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "player_characters";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "player_characters";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "user_id";
+            tableName: "player_characters";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        bodyComponentId: drizzle_orm_pg_core.PgColumn<{
+            name: "body_component_id";
+            tableName: "player_characters";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eyesComponentId: drizzle_orm_pg_core.PgColumn<{
+            name: "eyes_component_id";
+            tableName: "player_characters";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hairstyleComponentId: drizzle_orm_pg_core.PgColumn<{
+            name: "hairstyle_component_id";
+            tableName: "player_characters";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        outfitComponentId: drizzle_orm_pg_core.PgColumn<{
+            name: "outfit_component_id";
+            tableName: "player_characters";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "player_characters";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "player_characters";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const playerCharacterAccessories: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "player_character_accessories";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "player_character_accessories";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        playerCharacterId: drizzle_orm_pg_core.PgColumn<{
+            name: "player_character_id";
+            tableName: "player_character_accessories";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        accessoryComponentId: drizzle_orm_pg_core.PgColumn<{
+            name: "accessory_component_id";
+            tableName: "player_character_accessories";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        slot: drizzle_orm_pg_core.PgColumn<{
+            name: "slot";
+            tableName: "player_character_accessories";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 64;
+        }>;
+        equippedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "equipped_at";
+            tableName: "player_character_accessories";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "player_character_accessories";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+
+declare const achievementIntervalEnum: drizzle_orm_pg_core.PgEnum<["daily", "weekly"]>;
+declare const DeveloperStatusResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<["none", "pending", "approved"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "none" | "pending" | "approved";
+}, {
+    status: "none" | "pending" | "approved";
+}>;
+declare const UpsertGameMetadataSchema: z.ZodEffects<z.ZodObject<{
+    displayName: z.ZodString;
+    mapElementId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    platform: z.ZodEnum<["web", "godot", "unity"]>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    gameType: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hosted", "external"]>>>;
+    externalUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    displayName: string;
+    gameType: "hosted" | "external";
+    platform: "web" | "godot" | "unity";
+    metadata: Record<string, unknown>;
+    externalUrl?: string | undefined;
+    mapElementId?: string | null | undefined;
+}, {
+    displayName: string;
+    platform: "web" | "godot" | "unity";
+    gameType?: "hosted" | "external" | undefined;
+    externalUrl?: string | undefined;
+    mapElementId?: string | null | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>, {
+    displayName: string;
+    gameType: "hosted" | "external";
+    platform: "web" | "godot" | "unity";
+    metadata: Record<string, unknown>;
+    externalUrl?: string | undefined;
+    mapElementId?: string | null | undefined;
+}, {
+    displayName: string;
+    platform: "web" | "godot" | "unity";
+    gameType?: "hosted" | "external" | undefined;
+    externalUrl?: string | undefined;
+    mapElementId?: string | null | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+declare const ManifestV1Schema: z.ZodObject<{
+    version: z.ZodString;
+    bootMode: z.ZodEnum<["iframe", "module"]>;
+    entryPoint: z.ZodEffects<z.ZodString, string, string>;
+    /**
+     * An array of relative paths to CSS stylesheets.
+     * Currently, this property is ONLY utilized by the 'module' boot mode
+     * (`apps/cademy/src/lib/loader/boot-module.ts`) to load external
+     * stylesheets into the game's shadow DOM.
+     *
+     * This property is under review for potential deprecation and removal.
+     * The 'module' boot mode itself has not yet seen significant adoption
+     * or clear use-cases, and if support for module loading is removed in
+     * the future, this 'styles' property would become obsolete.
+     *
+     * If module-based games need styling, alternative approaches might involve
+     * bundling CSS within their JavaScript or managing style injection internally.
+     */
+    styles: z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodString, "many">>, string[] | undefined, string[] | undefined>;
+    /**
+     * Specifies the game or development platform.
+     * Current values include 'web', 'godot', and 'unity'.
+     * The default in the database is 'web'.
+     *
+     * IMPORTANT: This property is NOT CURRENTLY USED by the core loader
+     * or runtime systems in any functional way. It is present in the manifest
+     * but does not drive any specific behavior in `boot-iframe.ts` or
+     * `boot-module.ts` beyond being a piece of metadata.
+     *
+     * Potential Future Uses (Speculative):
+     * - Analytics: Could be used to gather stats on platform popularity/usage.
+     * - Developer Portal: Might inform UI/UX in the dev portal, e.g., showing
+     *   platform-specific guides or settings.
+     * - Loader Optimizations: In the future, the loader could potentially use this
+     *   to apply platform-specific loading strategies or workarounds, though this
+     *   is unlikely given the current generic boot process.
+     * - Asset Pipeline: Could hint to future asset pipeline tools about expected
+     *   project structures or build artifacts for different platforms.
+     *
+     * The field is intentionally kept somewhat generic. If finer-grained
+     * distinctions are ever needed (e.g., specific web frameworks like 'phaser',
+     * 'three'), this schema might need to be revisited or a separate
+     * 'platformVersion' or 'framework' field could be added.
+     */
+    platform: z.ZodEnum<["web", "godot", "unity"]>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    createdAt: string;
+    version: string;
+    platform: "web" | "godot" | "unity";
+    bootMode: "iframe" | "module";
+    entryPoint: string;
+    styles?: string[] | undefined;
+}, {
+    createdAt: string;
+    version: string;
+    platform: "web" | "godot" | "unity";
+    bootMode: "iframe" | "module";
+    entryPoint: string;
+    styles?: string[] | undefined;
+}>;
+declare const InsertItemSchema: drizzle_zod.BuildSchema<"insert", {
+    id: drizzle_orm_pg_core.PgColumn<{
+        name: "id";
+        tableName: "items";
+        dataType: "string";
+        columnType: "PgUUID";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    slug: drizzle_orm_pg_core.PgColumn<{
+        name: "slug";
+        tableName: "items";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    gameId: drizzle_orm_pg_core.PgColumn<{
+        name: "game_id";
+        tableName: "items";
+        dataType: "string";
+        columnType: "PgUUID";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    displayName: drizzle_orm_pg_core.PgColumn<{
+        name: "display_name";
+        tableName: "items";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    description: drizzle_orm_pg_core.PgColumn<{
+        name: "description";
+        tableName: "items";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    type: drizzle_orm_pg_core.PgColumn<{
+        name: "type";
+        tableName: "items";
+        dataType: "string";
+        columnType: "PgEnumColumn";
+        data: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "accessory" | "other";
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: ["currency", "badge", "trophy", "collectible", "consumable", "unlock", "upgrade", "accessory", "other"];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    isPlaceable: drizzle_orm_pg_core.PgColumn<{
+        name: "is_placeable";
+        tableName: "items";
+        dataType: "boolean";
+        columnType: "PgBoolean";
+        data: boolean;
+        driverParam: boolean;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    imageUrl: drizzle_orm_pg_core.PgColumn<{
+        name: "image_url";
+        tableName: "items";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    metadata: drizzle_orm_pg_core.PgColumn<{
+        name: "metadata";
+        tableName: "items";
+        dataType: "json";
+        columnType: "PgJsonb";
+        data: unknown;
+        driverParam: unknown;
+        notNull: false;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    createdAt: drizzle_orm_pg_core.PgColumn<{
+        name: "created_at";
+        tableName: "items";
+        dataType: "date";
+        columnType: "PgTimestamp";
+        data: Date;
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+}, {
+    imageUrl: z.ZodNullable<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}>;
+declare const UpdateItemSchema: z.ZodObject<Omit<{
+    id: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    gameId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    displayName: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<["currency", "badge", "trophy", "collectible", "consumable", "unlock", "upgrade", "accessory", "other"]>>;
+    isPlaceable: z.ZodOptional<z.ZodBoolean>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+}, "id" | "createdAt">, "strip", z.ZodTypeAny, {
+    description?: string | null | undefined;
+    displayName?: string | undefined;
+    slug?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    gameId?: string | null | undefined;
+    type?: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "accessory" | "other" | undefined;
+    isPlaceable?: boolean | undefined;
+    imageUrl?: string | null | undefined;
+}, {
+    description?: string | null | undefined;
+    displayName?: string | undefined;
+    slug?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    gameId?: string | null | undefined;
+    type?: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "accessory" | "other" | undefined;
+    isPlaceable?: boolean | undefined;
+    imageUrl?: string | null | undefined;
+}>;
+declare const InsertCurrencySchema: z.ZodObject<Omit<{
+    id: z.ZodOptional<z.ZodString>;
+    itemId: z.ZodString;
+    symbol: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isPrimary: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+}, "id" | "createdAt" | "updatedAt">, "strip", z.ZodTypeAny, {
+    itemId: string;
+    isPrimary: boolean;
+    symbol?: string | null | undefined;
+}, {
+    itemId: string;
+    symbol?: string | null | undefined;
+    isPrimary?: boolean | undefined;
+}>;
+declare const UpdateCurrencySchema: z.ZodObject<{
+    symbol: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    itemId: z.ZodOptional<z.ZodString>;
+    isPrimary: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    symbol?: string | null | undefined;
+    itemId?: string | undefined;
+    isPrimary?: boolean | undefined;
+}, {
+    symbol?: string | null | undefined;
+    itemId?: string | undefined;
+    isPrimary?: boolean | undefined;
+}>;
+declare const InsertShopListingSchema: z.ZodObject<Omit<{
+    id: z.ZodOptional<z.ZodString>;
+    itemId: z.ZodString;
+    currencyId: z.ZodString;
+    price: z.ZodNumber;
+    sellBackPercentage: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    stock: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    availableFrom: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    availableUntil: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+}, "id" | "createdAt" | "updatedAt">, "strip", z.ZodTypeAny, {
+    itemId: string;
+    currencyId: string;
+    price: number;
+    isActive: boolean;
+    sellBackPercentage?: number | null | undefined;
+    stock?: number | null | undefined;
+    availableFrom?: Date | null | undefined;
+    availableUntil?: Date | null | undefined;
+}, {
+    itemId: string;
+    currencyId: string;
+    price: number;
+    sellBackPercentage?: number | null | undefined;
+    stock?: number | null | undefined;
+    isActive?: boolean | undefined;
+    availableFrom?: Date | null | undefined;
+    availableUntil?: Date | null | undefined;
+}>;
+declare const UpdateShopListingSchema: z.ZodObject<{
+    itemId: z.ZodOptional<z.ZodString>;
+    currencyId: z.ZodOptional<z.ZodString>;
+    price: z.ZodOptional<z.ZodNumber>;
+    sellBackPercentage: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodNumber>>>;
+    stock: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodNumber>>>;
+    isActive: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    availableFrom: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodDate>>>;
+    availableUntil: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodDate>>>;
+}, "strip", z.ZodTypeAny, {
+    itemId?: string | undefined;
+    currencyId?: string | undefined;
+    price?: number | undefined;
+    sellBackPercentage?: number | null | undefined;
+    stock?: number | null | undefined;
+    isActive?: boolean | undefined;
+    availableFrom?: Date | null | undefined;
+    availableUntil?: Date | null | undefined;
+}, {
+    itemId?: string | undefined;
+    currencyId?: string | undefined;
+    price?: number | undefined;
+    sellBackPercentage?: number | null | undefined;
+    stock?: number | null | undefined;
+    isActive?: boolean | undefined;
+    availableFrom?: Date | null | undefined;
+    availableUntil?: Date | null | undefined;
+}>;
+/**
+ * Achievement Completion Types
+ */
+declare const ACHIEVEMENT_COMPLETION_TYPES: readonly ["time_played_session", "interaction", "leaderboard_rank"];
+type AchievementCompletionType = (typeof ACHIEVEMENT_COMPLETION_TYPES)[number];
+
+type CharacterComponent = typeof characterComponents.$inferSelect;
+type PlayerCharacter = typeof playerCharacters.$inferSelect & {
+    accessories?: PlayerCharacterAccessory[];
+};
+type PlayerCharacterAccessory = typeof playerCharacterAccessories.$inferSelect;
+type GameRow = typeof games.$inferSelect;
+type BaseGame = Omit<GameRow, 'gameType' | 'assetBundleBase' | 'externalUrl'>;
+type HostedGame = BaseGame & {
+    gameType: 'hosted';
+    assetBundleBase: string;
+    externalUrl: null;
+};
+type ExternalGame = BaseGame & {
+    gameType: 'external';
+    assetBundleBase: null;
+    externalUrl: string;
+};
+type Game = HostedGame | ExternalGame;
+type GameStateData = Record<string, unknown>;
+type UpsertGameMetadataInput = z.infer<typeof UpsertGameMetadataSchema>;
+type Item = typeof items.$inferSelect;
+type InventoryItem = typeof inventoryItems.$inferSelect;
+type ShopListing = typeof shopListings.$inferSelect;
+type InsertItemInput = z.infer<typeof InsertItemSchema>;
+type UpdateItemInput = z.infer<typeof UpdateItemSchema>;
+type InsertCurrencyInput = z.infer<typeof InsertCurrencySchema>;
+type UpdateCurrencyInput = z.infer<typeof UpdateCurrencySchema>;
+type InsertShopListingInput = z.infer<typeof InsertShopListingSchema>;
+type UpdateShopListingInput = z.infer<typeof UpdateShopListingSchema>;
+interface PlaceableItemMetadata {
+    tilesWide?: number;
+    tilesHigh?: number;
+    flippable?: boolean;
+    [key: string]: unknown;
+}
+type MapElement = typeof mapElements.$inferSelect;
+type MapObject = typeof mapObjects.$inferSelect;
+interface MapData {
+    id: string;
+    identifier: string;
+    displayName: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+interface CreateMapObjectData {
+    itemId: string;
+    worldX: number;
+    worldY: number;
+    width?: number;
+    height?: number;
+    rotation?: number;
+    scale?: number;
+    metadata?: Record<string, unknown>;
+}
+
+type User = typeof users.$inferSelect;
+type DeveloperStatusResponse = z.infer<typeof DeveloperStatusResponseSchema>;
+type DeveloperStatusValue = DeveloperStatusResponse['status'];
+/**
+ * User data with authentication provider information.
+ * Returned by the /users/me endpoint with additional auth context.
+ */
+type AuthenticatedUser = User & {
+    /** Whether the user authenticated via Timeback SSO */
+    hasTimebackAccount: boolean;
+};
+
+/**
+ * Cross-Domain Composite Types
+ * Types that combine data from multiple domains
+ */
+type ManifestV1 = z.infer<typeof ManifestV1Schema>;
+/**
+ * Character-related Composite Types
+ * Types that combine character component data with sprite sheet information
+ */
+type CharacterComponentWithSpriteUrl = CharacterComponent & {
+    spriteSheetUrl: string;
+};
+type InventoryItemWithItem = Omit<InventoryItem, 'itemId'> & {
+    item: Item;
+};
+type HostedGameWithManifest = HostedGame & {
+    manifest: ManifestV1;
+};
+type FetchedGame = HostedGameWithManifest | GameRow;
+/**
+ * Map-related Composite Types
+ * Types that combine map, game, and item data for rendering and interaction
+ */
+interface MapElementWithGame extends MapElement {
+    game: Pick<Game, 'id' | 'displayName'> | null;
+}
+interface MapObjectWithItem extends MapObject {
+    item: Pick<Item, 'id' | 'slug' | 'displayName' | 'description' | 'imageUrl' | 'isPlaceable'> & {
+        metadata: PlaceableItemMetadata;
+    };
+}
+/**
+ * Shop-related Composite Types
+ * Types that combine inventory, currency, and shop listing data for commerce operations
+ */
+interface ShopDisplayItem extends Omit<Item, 'createdAt'> {
+    listingId: string;
+    shopPrice: number;
+    currencyId: string;
+    currencySymbol?: string | null;
+    currencyDisplayName?: string | null;
+    currencyImageUrl?: string | null;
+    stock?: number | null;
+    sellBackPercentage?: number | null;
+}
+interface ShopCurrency {
+    id: string;
+    symbol: string | null;
+    isPrimary: boolean;
+    displayName?: string | null;
+    imageUrl?: string | null;
+}
+interface ShopViewResponse {
+    shopItems: ShopDisplayItem[];
+    currencies: ShopCurrency[];
+}
+/**
+ * Leaderboard Composite Types
+ * Types that combine leaderboard, user, and game data
+ */
+interface GameLeaderboardEntry {
+    rank: number;
+    userId: string;
+    username: string;
+    userImage?: string | null;
+    score: number;
+    achievedAt: Date;
+    metadata?: Record<string, unknown>;
+    gameId: string;
+    gameTitle: string;
+    gameSlug: string;
+}
+
+type UserLevel = typeof userLevels.$inferSelect;
+type LevelConfig = typeof levelConfigs.$inferSelect;
+interface LeaderboardOptions {
+    timeframe?: 'all_time' | 'monthly' | 'weekly' | 'daily';
+    limit?: number;
+    offset?: number;
+    gameId?: string;
+}
+interface LeaderboardEntry {
+    rank: number;
+    userId: string;
+    username: string;
+    userImage?: string | null;
+    score: number;
+    achievedAt: Date;
+    metadata?: Record<string, unknown>;
+    gameId?: string;
+    gameTitle?: string;
+    gameSlug?: string;
+}
+interface UserRankResponse {
+    rank: number;
+    score: number;
+    userId: string;
+}
+interface UserScore$1 {
+    id: string;
+    score: number;
+    achievedAt: Date;
+    metadata?: Record<string, unknown>;
+    gameId: string;
+    gameTitle: string;
+    gameSlug: string;
+}
+interface SpriteTemplateData {
+    tileSize: number;
+    tileHeight: number;
+    columns: number;
+    rows: number;
+    spacing: number;
+    animations: {
+        base_right: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        base_up: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        base_left: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        base_down: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        idle_right: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        walk_right: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        idle_up: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        walk_up: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        idle_left: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        walk_left: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        idle_down: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+        walk_down: {
+            row: number;
+            frameStart: number;
+            numFrames: number;
+            fps: number;
+        };
+    };
+}
+type TodayXpResponse = {
+    xp: number;
+    date: string;
+};
+type TotalXpResponse = {
+    totalXp: number;
+};
+type XpHistoryResponse = {
+    history: Array<{
+        date: string;
+        xp: number;
+    }>;
+};
+
+type AchievementIntervalType = (typeof achievementIntervalEnum.enumValues)[number];
+/**
+ * Current-interval achievement with computed status and window metadata
+ */
+interface AchievementCurrent {
+    id: string;
+    title: string;
+    description?: string | null;
+    intervalType: AchievementIntervalType;
+    rewardCredits: number;
+    limitPerInterval: number;
+    completionType: AchievementCompletionType;
+    completionConfig: Record<string, unknown>;
+    scope: Record<string, unknown>;
+    active: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    status: 'available' | 'completed';
+    intervalKey: string;
+    windowStart: string;
+    windowEnd: string;
+}
+/**
+ * Historical entry representing a prior claim within an interval
+ */
+interface AchievementHistoryEntry {
+    achievementId: string;
+    title: string;
+    rewardCredits: number;
+    createdAt: string;
+    intervalKey: string;
+}
+/**
+ * Response returned when submitting achievement progress
+ */
+interface AchievementProgressResponse {
+    achievementId: string;
+    status: 'completed' | 'already_completed';
+    rewardCredits: number;
+    intervalKey: string;
+    createdAt: string;
+}
+
+interface ClientConfig {
+    baseUrl: string;
+    token?: string;
+    gameId?: string;
+    autoStartSession?: boolean;
+}
+type AuthProviderType = (typeof AuthProvider)[keyof typeof AuthProvider];
+interface AuthOptions {
+    /** The identity provider to use for authentication */
+    provider: AuthProviderType;
+    /** The OAuth callback URL where your server handles the callback */
+    callbackUrl: string;
+    /** Authentication mode - auto detects best option based on context */
+    mode?: 'auto' | 'popup' | 'redirect';
+    /** Callback for authentication state changes */
+    onStateChange?: (state: AuthStateUpdate) => void;
+    /** Custom OAuth configuration (for users embedding the SDK outside of the Playcademy platform) */
+    oauth?: {
+        clientId: string;
+        authorizationEndpoint?: string;
+        tokenEndpoint?: string;
+        scope?: string;
+    };
+    /**
+     * Optional custom data to encode in OAuth state parameter.
+     * By default, the SDK automatically includes playcademy_user_id and game_id.
+     * Use this to add additional custom data if needed.
+     */
+    stateData?: Record<string, string>;
+}
+interface AuthStateUpdate {
+    /** Current status of the authentication flow */
+    status: 'opening_popup' | 'exchanging_token' | 'complete' | 'error';
+    /** Human-readable message about the current state */
+    message: string;
+    /** Error details if status is 'error' */
+    error?: Error;
+}
+interface AuthResult {
+    /** Whether authentication was successful */
+    success: boolean;
+    /** User information if authentication was successful */
+    user?: UserInfo;
+    /** Error if authentication failed */
+    error?: Error;
+}
+/**
+ * Standard OAuth/OIDC user claims returned from identity providers
+ * This is what external identity providers (like Timeback) return
+ */
+interface UserInfo {
+    /** Unique user identifier (sub claim from JWT) */
+    sub: string;
+    /** User's email address */
+    email: string;
+    /** User's display name */
+    name: string;
+    /** Whether the email has been verified */
+    email_verified: boolean;
+    /** Optional given name (first name) */
+    given_name?: string;
+    /** Optional family name (last name) */
+    family_name?: string;
+    /** Additional user attributes from the identity provider */
+    [key: string]: unknown;
+}
+/**
+ * Authentication state change event payload.
+ * Used when authentication state changes in the application.
+ */
+interface AuthStateChangePayload {
+    /** Whether the user is currently authenticated */
+    authenticated: boolean;
+    /** User information if authenticated, null otherwise */
+    user: UserInfo | null;
+    /** Error information if authentication failed */
+    error: Error | null;
+}
+/**
+ * OAuth callback event payload.
+ * Used when OAuth flow completes in popup/new-tab windows.
+ */
+interface AuthCallbackPayload {
+    /** OAuth authorization code */
+    code: string;
+    /** OAuth state parameter for CSRF protection */
+    state: string;
+    /** Error message if OAuth flow failed */
+    error: string | null;
+}
+/**
+ * Token refresh event payload.
+ * Sent when authentication token is updated.
+ */
+interface TokenRefreshPayload {
+    /** New authentication token */
+    token: string;
+    /** Token expiration timestamp */
+    exp: number;
+}
+/**
+ * Telemetry event payload.
+ * Performance metrics sent from the game.
+ */
+interface TelemetryPayload {
+    /** Frames per second */
+    fps: number;
+    /** Memory usage in MB */
+    mem: number;
+}
+/**
+ * Keyboard event payload.
+ * Key events forwarded from the game.
+ */
+interface KeyEventPayload {
+    /** Key value (e.g., 'Escape', 'F1') */
+    key: string;
+    /** Key code (optional) */
+    code?: string;
+    /** Event type */
+    type: 'keydown' | 'keyup';
+}
+interface ClientEvents {
+    authChange: {
+        token: string | null;
+    };
+    inventoryChange: {
+        itemId: string;
+        delta: number;
+        newTotal: number;
+    };
+    levelUp: {
+        oldLevel: number;
+        newLevel: number;
+        creditsAwarded: number;
+    };
+    xpGained: {
+        amount: number;
+        totalXP: number;
+        leveledUp: boolean;
+    };
+}
+type GameContextPayload = {
+    token: string;
+    baseUrl: string;
+    realtimeUrl: string;
+    gameId: string;
+    forwardKeys?: string[];
+};
+type LoginResponse = {
+    token: string;
+};
+type GameTokenResponse = {
+    token: string;
+    exp: number;
+};
+type StartSessionResponse = {
+    sessionId: string;
+};
+type InventoryMutationResponse = {
+    newTotal: number;
+};
+type DevUploadEvent = {
+    type: 'init';
+} | {
+    type: 's3Progress';
+    loaded: number;
+    total: number;
+    percent: number;
+} | {
+    type: 'finalizeStart';
+} | {
+    type: 'finalizeProgress';
+    percent: number;
+    currentFileLabel?: string;
+} | {
+    type: 'finalizeStatus';
+    message: string;
+} | {
+    type: 'close';
+};
+type DevUploadHooks = {
+    onEvent?: (e: DevUploadEvent) => void;
+    onClose?: () => void;
+};
+
+/**
+ * OAuth 2.0 implementation for the Playcademy SDK
+ */
+
+/**
+ * Parses an OAuth state parameter to extract CSRF token and any encoded data.
+ *
+ * @param state - The OAuth state parameter to parse
+ * @returns Object containing CSRF token and optional decoded data
+ */
+declare function parseOAuthState(state: string): {
+    csrfToken: string;
+    data?: Record<string, string>;
+};
+
+/**
+ * Response type for the realtime token API
+ */
+interface RealtimeTokenResponse {
+    token: string;
+}
+
+/**
+ * Cache configuration types for runtime customization
+ */
+/**
+ * Runtime configuration for TTL cache behavior
+ */
+interface TTLCacheConfig {
+    /** Time-to-live in milliseconds. Set to 0 to disable caching for this call. */
+    ttl?: number;
+    /** Force refresh, bypassing cache */
+    force?: boolean;
+    /** Skip cache and fetch fresh data (alias for force) */
+    skipCache?: boolean;
+}
+/**
+ * Runtime configuration for cooldown cache behavior
+ */
+interface CooldownCacheConfig {
+    /** Cooldown period in milliseconds. Set to 0 to disable cooldown for this call. */
+    cooldown?: number;
+    /** Force refresh, bypassing cooldown */
+    force?: boolean;
+}
+
+interface CharacterComponentsOptions {
+    /**
+     * Optional level filter for components
+     * When provided, only components available at this level or below are returned
+     */
+    level?: number;
+    /**
+     * Whether to bypass the cache and force a fresh API request
+     * Default: false (use cache when available)
+     */
+    skipCache?: boolean;
+}
+interface CreateCharacterData {
+    bodyComponentId: string;
+    eyesComponentId: string;
+    hairstyleComponentId: string;
+    outfitComponentId: string;
+}
+interface UpdateCharacterData {
+    bodyComponentId?: string;
+    eyesComponentId?: string;
+    hairstyleComponentId?: string;
+    outfitComponentId?: string;
+}
+
+interface ScoreSubmission {
+    id: string;
+    score: number;
+    achievedAt: Date;
+}
+
+/**
+ * Combined response type for summary method
+ */
+type XpSummaryResponse = {
+    today: TodayXpResponse;
+    total: TotalXpResponse;
+};
+
+interface UserScore {
+    id: string;
+    score: number;
+    achievedAt: Date;
+    metadata?: Record<string, unknown>;
+    gameId: string;
+    gameTitle: string;
+    gameSlug: string;
+}
+
+/**
+ * Auto-initializes a PlaycademyClient with context from the environment.
+ * Works in both iframe mode (production/development) and standalone mode (local dev).
+ *
+ * This is the recommended way to initialize the SDK as it automatically:
+ * - Detects the runtime environment (iframe vs standalone)
+ * - Configures the client with the appropriate context
+ * - Sets up event listeners for token refresh
+ * - Exposes the client for debugging in development mode
+ *
+ * @returns Promise resolving to a fully initialized PlaycademyClient
+ * @throws Error if not running in a browser context
+ *
+ * @example
+ * ```typescript
+ * const client = await PlaycademyClient.init()
+ * const user = await client.users.me()
+ * ```
+ */
+declare function init(): Promise<PlaycademyClient>;
+
+/**
+ * Authenticates a user with email and password.
+ *
+ * This is a standalone authentication method that doesn't require an initialized client.
+ * Use this for login flows before creating a client instance.
+ *
+ * @deprecated Use client.auth.login() instead for better error handling and automatic token management
+ *
+ * @param baseUrl - The base URL of the Playcademy API
+ * @param email - User's email address
+ * @param password - User's password
+ * @returns Promise resolving to authentication response with token
+ * @throws PlaycademyError if authentication fails or network error occurs
+ *
+ * @example
+ * ```typescript
+ * // Preferred approach:
+ * const client = new PlaycademyClient({ baseUrl: '/api' })
+ * const result = await client.auth.login({
+ *   email: 'user@example.com',
+ *   password: 'password'
+ * })
+ *
+ * // Legacy approach (still works):
+ * try {
+ *   const response = await PlaycademyClient.login('/api', 'user@example.com', 'password')
+ *   const client = new PlaycademyClient({ token: response.token })
+ * } catch (error) {
+ *   console.error('Login failed:', error.message)
+ * }
+ * ```
+ */
+declare function login(baseUrl: string, email: string, password: string): Promise<LoginResponse>;
+
+/** Permitted HTTP verbs */
+type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+/**
+ * Main Playcademy SDK client for interacting with the platform API.
+ * Provides namespaced access to all platform features including games, users, inventory, and more.
+ */
+declare class PlaycademyClient {
+    private baseUrl;
+    private token?;
+    private gameId?;
+    private config;
+    private listeners;
+    private internalClientSessionId?;
+    private authContext?;
+    private initPayload?;
+    /**
+     * Creates a new PlaycademyClient instance.
+     *
+     * @param config - Optional configuration object
+     * @param config.baseUrl - Base URL for API requests (defaults to '/api')
+     * @param config.token - Authentication token
+     * @param config.gameId - Game ID for automatic session management
+     * @param config.autoStartSession - Automatically start a game session?
+     */
+    constructor(config?: Partial<ClientConfig>);
+    /**
+     * Gets the effective base URL for API requests.
+     * Converts relative URLs to absolute URLs in browser environments.
+     *
+     * @returns The complete base URL for API requests
+     */
+    getBaseUrl(): string;
+    /**
+     * Simple ping method for testing connectivity.
+     *
+     * @returns 'pong' string response
+     */
+    ping(): string;
+    /**
+     * Sets the authentication token for API requests.
+     * Emits an 'authChange' event when the token changes.
+     *
+     * @param token - The authentication token, or null to clear
+     */
+    setToken(token: string | null): void;
+    /**
+     * Checks if the client has a valid API token for making Playcademy API requests.
+     *
+     * For games (iframe context): Checks if we have a valid token from the parent.
+     * For Cademy (standalone): Checks if we have a token from better-auth.
+     *
+     * Note: This checks for API authentication, not whether a user has linked
+     * their identity via OAuth.
+     *
+     * @returns true if API token exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (client.isAuthenticated()) {
+     *     // Can make API calls
+     *     const games = await client.games.list()
+     * } else {
+     *     console.error('No API token available')
+     * }
+     * ```
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Registers a callback to be called when authentication state changes.
+     *
+     * @param callback - Function to call when auth state changes
+     */
+    onAuthChange(callback: (token: string | null) => void): void;
+    /**
+     * Sets the authentication context for the client.
+     * This is called during initialization to store environment info.
+     * @internal
+     */
+    _setAuthContext(context: {
+        isInIframe: boolean;
+    }): void;
+    /**
+     * Registers an event listener for client events.
+     *
+     * @param event - The event type to listen for
+     * @param callback - Function to call when the event is emitted
+     */
+    on<E extends keyof ClientEvents>(event: E, callback: (payload: ClientEvents[E]) => void): void;
+    /**
+     * Emits an event to all registered listeners.
+     *
+     * @param event - The event type to emit
+     * @param payload - The event payload
+     */
+    private emit;
+    /**
+     * Makes an authenticated HTTP request to the API.
+     *
+     * @param path - API endpoint path
+     * @param method - HTTP method
+     * @param body - Request body (optional)
+     * @param headers - Additional headers (optional)
+     * @returns Promise resolving to the response data
+     */
+    protected request<T>(path: string, method: Method, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    /**
+     * Ensures a gameId is available, throwing an error if not.
+     *
+     * @returns The gameId
+     * @throws PlaycademyError if no gameId is configured
+     */
+    private _ensureGameId;
+    /**
+     * Detects and sets the authentication context (iframe vs standalone).
+     * Safe to call in any environment - isInIframe handles browser detection.
+     */
+    private _detectAuthContext;
+    /**
+     * Initializes an internal game session for automatic session management.
+     * Only starts a session if:
+     * 1. A gameId is configured
+     * 2. No session already exists
+     * 3. autoStartSession is enabled (defaults to false)
+     */
+    private _initializeInternalSession;
+    /** Platform API authentication methods (login, logout) */
+    auth: {
+        login: (credentials: {
+            email: string;
+            password: string;
+        }) => Promise<{
+            success: boolean;
+            token?: string;
+            error?: string;
+        }>;
+        logout: () => Promise<void>;
+    };
+    /** Identity provider connection methods (connect external accounts) */
+    identity: {
+        readonly user: {
+            sub: string;
+            email: string;
+            name: string;
+            email_verified: true;
+            given_name: undefined;
+            family_name: undefined;
+        } | null;
+        connect: (options: AuthOptions) => Promise<AuthResult>;
+        _getContext: () => {
+            isInIframe: boolean;
+        };
+    };
+    /** Runtime methods (getGameToken, exit) */
+    runtime: {
+        getGameToken: (gameId: string, options?: {
+            apply?: boolean;
+        }) => Promise<GameTokenResponse>;
+        exit: () => Promise<void>;
+        onInit: (handler: (context: GameContextPayload) => void) => void;
+        onTokenRefresh: (handler: (data: {
+            token: string;
+            exp: number;
+        }) => void) => void;
+        onPause: (handler: () => void) => void;
+        onResume: (handler: () => void) => void;
+        onForceExit: (handler: () => void) => void;
+        onOverlay: (handler: (isVisible: boolean) => void) => void;
+        ready: () => void;
+        sendTelemetry: (data: {
+            fps: number;
+            mem: number;
+        }) => void;
+        removeListener: (eventType: MessageEvents, handler: ((context: GameContextPayload) => void) | ((data: {
+            token: string;
+            exp: number;
+        }) => void) | (() => void) | ((isVisible: boolean) => void)) => void;
+        removeAllListeners: () => void;
+        getListenerCounts: () => Record<string, number>;
+    };
+    /** Game management methods (fetch, list, saveState, loadState, sessions) */
+    games: {
+        fetch: (gameIdOrSlug: string, options?: TTLCacheConfig) => Promise<FetchedGame>;
+        list: (options?: TTLCacheConfig) => Promise<Array<Game>>;
+        saveState: (state: Record<string, unknown>) => Promise<void>;
+        loadState: () => Promise<GameStateData>;
+        startSession: (gameId?: string) => Promise<StartSessionResponse>;
+        endSession: (sessionId: string, gameId?: string) => Promise<void>;
+        token: {
+            create: (gameId: string, options?: {
+                apply?: boolean;
+            }) => Promise<GameTokenResponse>;
+        };
+        leaderboard: {
+            get: (gameId: string, options?: {
+                limit?: number;
+                offset?: number;
+            }) => Promise<LeaderboardEntry[]>;
+        };
+    };
+    /** User methods (me, inventory management) */
+    users: {
+        me: () => Promise<AuthenticatedUser>;
+        inventory: {
+            get: () => Promise<InventoryItemWithItem[]>;
+            add: (identifier: string, qty: number) => Promise<InventoryMutationResponse>;
+            remove: (identifier: string, qty: number) => Promise<InventoryMutationResponse>;
+            quantity: (identifier: string) => Promise<number>;
+            has: (identifier: string, minQuantity?: number) => Promise<boolean>;
+        };
+        scores: {
+            get: (userIdOrOptions?: string | {
+                limit?: number;
+                gameId?: string;
+            }, options?: {
+                limit?: number;
+                gameId?: string;
+            }) => Promise<UserScore[]>;
+        };
+    };
+    /** Developer tools (auth, games, keys management) */
+    dev: {
+        status: {
+            apply: () => Promise<void>;
+            get: () => Promise<DeveloperStatusValue>;
+        };
+        games: {
+            upsert: (slug: string, metadata: UpsertGameMetadataInput, file: File | Blob | null, hooks?: DevUploadHooks) => Promise<Game>;
+            update: (gameId: string, props: Partial<Game>) => Promise<void>;
+            delete: (gameId: string) => Promise<void>;
+        };
+        keys: {
+            create: (label?: string) => Promise<{
+                id: string;
+                createdAt: Date;
+                userId: string;
+                label: string | null;
+                keyHash: string;
+            }>;
+            list: () => Promise<{
+                id: string;
+                createdAt: Date;
+                userId: string;
+                label: string | null;
+                keyHash: string;
+            }[]>;
+            revoke: (keyId: string) => Promise<void>;
+        };
+        items: {
+            create: (gameId: string, slug: string, itemData: Omit<InsertItemInput, "slug" | "gameId">) => Promise<Item>;
+            update: (gameId: string, itemId: string, updates: UpdateItemInput) => Promise<Item>;
+            list: (gameId: string) => Promise<Array<Item>>;
+            get: (gameId: string, slug: string) => Promise<Item>;
+            delete: (gameId: string, itemId: string) => Promise<void>;
+            shop: {
+                create: (gameId: string, itemId: string, listingData: Omit<InsertShopListingInput, "itemId">) => Promise<ShopListing>;
+                get: (gameId: string, itemId: string) => Promise<ShopListing | null>;
+                update: (gameId: string, itemId: string, updates: UpdateShopListingInput) => Promise<ShopListing>;
+                delete: (gameId: string, itemId: string) => Promise<void>;
+                list: (gameId: string) => Promise<Array<ShopListing & {
+                    item: Item;
+                }>>;
+            };
+        };
+    };
+    /** Map methods (elements) */
+    maps: {
+        get: (identifier: string) => Promise<MapData>;
+        elements: (mapId: string) => Promise<MapElementWithGame[]>;
+        objects: {
+            list: (mapId: string) => Promise<MapObjectWithItem[]>;
+            create: (mapId: string, objectData: CreateMapObjectData) => Promise<MapObjectWithItem>;
+            delete: (mapId: string, objectId: string) => Promise<void>;
+        };
+    };
+    /** Admin methods (games, items, currencies, shop listings) */
+    admin: {
+        games: {
+            pauseGame: (gameId: string) => Promise<void>;
+            resumeGame: (gameId: string) => Promise<void>;
+        };
+        items: {
+            create: (props: InsertItemInput) => Promise<{
+                id: string;
+                createdAt: Date;
+                type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "accessory" | "other";
+                gameId: string | null;
+                slug: string;
+                displayName: string;
+                metadata: unknown;
+                description: string | null;
+                isPlaceable: boolean;
+                imageUrl: string | null;
+            }>;
+            get: (itemId: string) => Promise<{
+                id: string;
+                createdAt: Date;
+                type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "accessory" | "other";
+                gameId: string | null;
+                slug: string;
+                displayName: string;
+                metadata: unknown;
+                description: string | null;
+                isPlaceable: boolean;
+                imageUrl: string | null;
+            }>;
+            list: () => Promise<{
+                id: string;
+                createdAt: Date;
+                type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "accessory" | "other";
+                gameId: string | null;
+                slug: string;
+                displayName: string;
+                metadata: unknown;
+                description: string | null;
+                isPlaceable: boolean;
+                imageUrl: string | null;
+            }[]>;
+            update: (itemId: string, props: UpdateItemInput) => Promise<{
+                id: string;
+                createdAt: Date;
+                type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "accessory" | "other";
+                gameId: string | null;
+                slug: string;
+                displayName: string;
+                metadata: unknown;
+                description: string | null;
+                isPlaceable: boolean;
+                imageUrl: string | null;
+            }>;
+            delete: (itemId: string) => Promise<void>;
+        };
+        currencies: {
+            create: (props: InsertCurrencyInput) => Promise<{
+                symbol: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                itemId: string;
+                isPrimary: boolean;
+            }>;
+            get: (currencyId: string) => Promise<{
+                symbol: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                itemId: string;
+                isPrimary: boolean;
+            }>;
+            list: () => Promise<{
+                symbol: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                itemId: string;
+                isPrimary: boolean;
+            }[]>;
+            update: (currencyId: string, props: UpdateCurrencyInput) => Promise<{
+                symbol: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                itemId: string;
+                isPrimary: boolean;
+            }>;
+            delete: (currencyId: string) => Promise<void>;
+        };
+        shopListings: {
+            create: (props: InsertShopListingInput) => Promise<{
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                itemId: string;
+                currencyId: string;
+                price: number;
+                sellBackPercentage: number | null;
+                stock: number | null;
+                isActive: boolean;
+                availableFrom: Date | null;
+                availableUntil: Date | null;
+            }>;
+            get: (listingId: string) => Promise<{
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                itemId: string;
+                currencyId: string;
+                price: number;
+                sellBackPercentage: number | null;
+                stock: number | null;
+                isActive: boolean;
+                availableFrom: Date | null;
+                availableUntil: Date | null;
+            }>;
+            list: () => Promise<{
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                itemId: string;
+                currencyId: string;
+                price: number;
+                sellBackPercentage: number | null;
+                stock: number | null;
+                isActive: boolean;
+                availableFrom: Date | null;
+                availableUntil: Date | null;
+            }[]>;
+            update: (listingId: string, props: UpdateShopListingInput) => Promise<{
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                itemId: string;
+                currencyId: string;
+                price: number;
+                sellBackPercentage: number | null;
+                stock: number | null;
+                isActive: boolean;
+                availableFrom: Date | null;
+                availableUntil: Date | null;
+            }>;
+            delete: (listingId: string) => Promise<void>;
+        };
+    };
+    /** Shop methods (view) */
+    shop: {
+        view: () => Promise<ShopViewResponse>;
+    };
+    /** Level methods (levels) */
+    levels: {
+        get: () => Promise<UserLevel>;
+        progress: (options?: CooldownCacheConfig) => Promise<{
+            level: number;
+            currentXp: number;
+            xpToNextLevel: number;
+            totalXP: number;
+        }>;
+        config: {
+            list: () => Promise<LevelConfig[]>;
+            get: (level: number) => Promise<LevelConfig | null>;
+        };
+    };
+    /** TimeBack XP methods (today, total, history) */
+    timeback: {
+        xp: {
+            today: (options?: {
+                date?: string;
+                timezone?: string;
+            }) => Promise<TodayXpResponse>;
+            total: () => Promise<TotalXpResponse>;
+            history: (options?: {
+                startDate?: string;
+                endDate?: string;
+            }) => Promise<XpHistoryResponse>;
+            summary: (options?: {
+                date?: string;
+                timezone?: string;
+            }) => Promise<XpSummaryResponse>;
+        };
+    };
+    /** Telemetry methods (pushMetrics) */
+    telemetry: {
+        pushMetrics: (metrics: Record<string, number>) => Promise<void>;
+    };
+    /** Credits methods (credits management) */
+    credits: {
+        balance: () => Promise<number>;
+        add: (amount: number) => Promise<number>;
+        spend: (amount: number) => Promise<number>;
+    };
+    /** Platform-wide leaderboard methods (fetch, getUserRank) */
+    leaderboard: {
+        fetch: (options?: LeaderboardOptions) => Promise<GameLeaderboardEntry[]>;
+        getUserRank: (gameId: string, userId: string) => Promise<UserRankResponse>;
+    };
+    /** Platform-wide scores methods (submit, getUserScores) */
+    scores: {
+        submit: (gameId: string, score: number, metadata?: Record<string, unknown>) => Promise<ScoreSubmission>;
+        getByUser: (gameId: string, userId: string, options?: {
+            limit?: number;
+        }) => Promise<UserScore$1[]>;
+    };
+    /** Character methods (get, create, update, components) */
+    character: {
+        get: (userId?: string) => Promise<PlayerCharacter | null>;
+        create: (characterData: CreateCharacterData) => Promise<PlayerCharacter>;
+        update: (updates: UpdateCharacterData) => Promise<PlayerCharacter>;
+        components: {
+            list: (options?: CharacterComponentsOptions & TTLCacheConfig) => Promise<CharacterComponentWithSpriteUrl[]>;
+            clearCache: (key?: string) => void;
+            getCacheKeys: () => string[];
+        };
+        accessories: {
+            equip: (slot: string, componentId: string) => Promise<PlayerCharacterAccessory>;
+            remove: (slot: string) => Promise<{
+                success: boolean;
+            }>;
+            list: () => Promise<PlayerCharacterAccessory[]>;
+        };
+    };
+    /** Sprites methods (templates) */
+    sprites: {
+        templates: {
+            get: (slug: string) => Promise<SpriteTemplateData>;
+        };
+    };
+    /** Realtime methods (token) */
+    realtime: {
+        token: {
+            get: () => Promise<RealtimeTokenResponse>;
+        };
+        open(channel?: string, url?: string): Promise<_playcademy_realtime_server_types.RealtimeChannel>;
+    };
+    /** Achievements methods (list, history, progress) */
+    achievements: {
+        list: (options?: TTLCacheConfig) => Promise<AchievementCurrent[]>;
+        history: {
+            list: (queryOptions?: {
+                limit?: number;
+            }, cacheOptions?: TTLCacheConfig) => Promise<AchievementHistoryEntry[]>;
+        };
+        progress: {
+            submit: (achievementId: string) => Promise<AchievementProgressResponse>;
+        };
+    };
+    /** Auto-initializes a PlaycademyClient with context from the environment */
+    static init: typeof init;
+    /** Authenticates a user with email and password */
+    static login: typeof login;
+    /** Static identity utilities for OAuth operations */
+    static identity: {
+        parseOAuthState: typeof parseOAuthState;
+    };
+}
+
+/**
+ * @fileoverview Playcademy Messaging System
+ *
+ * This file implements a unified messaging system for the Playcademy platform that handles
+ * communication between different contexts:
+ *
+ * 1. **Iframe-to-Parent Communication**: When games run inside iframes (production/development),
+ *    they need to communicate with the parent window using postMessage API
+ *
+ * 2. **Local Communication**: When games run in the same context (local development),
+ *    they use CustomEvents for internal messaging
+ *
+ * The system automatically detects the runtime environment and chooses the appropriate
+ * transport method, abstracting this complexity from the developer.
+ *
+ * **Architecture Overview**:
+ * - Games run in iframes for security and isolation
+ * - Parent window (Playcademy shell) manages game lifecycle
+ * - Messages flow bidirectionally between parent and iframe
+ * - Local development mode simulates this architecture without iframes
+ */
+
+/**
+ * Enumeration of all message types used in the Playcademy messaging system.
+ *
+ * **Message Flow Patterns**:
+ *
+ * **Parent → Game (Overworld → Game)**:
+ * - INIT: Provides game with authentication token and configuration
+ * - TOKEN_REFRESH: Updates game's authentication token before expiry
+ * - PAUSE/RESUME: Controls game execution state
+ * - FORCE_EXIT: Immediately terminates the game
+ * - OVERLAY: Shows/hides UI overlays over the game
+ *
+ * **Game → Parent (Game → Overworld)**:
+ * - READY: Game has loaded and is ready to receive messages
+ * - EXIT: Game requests to be closed (user clicked exit, game ended, etc.)
+ * - TELEMETRY: Game reports performance metrics (FPS, memory usage, etc.)
+ */
+declare enum MessageEvents {
+    /**
+     * Initializes the game with authentication context and configuration.
+     * Sent immediately after game iframe loads.
+     * Payload:
+     * - `baseUrl`: string
+     * - `token`: string
+     * - `gameId`: string
+     */
+    INIT = "PLAYCADEMY_INIT",
+    /**
+     * Updates the game's authentication token before it expires.
+     * Sent periodically to maintain valid authentication.
+     * Payload:
+     * - `token`: string
+     * - `exp`: number
+     */
+    TOKEN_REFRESH = "PLAYCADEMY_TOKEN_REFRESH",
+    /**
+     * Pauses game execution (e.g., when user switches tabs).
+     * Game should pause timers, animations, and user input.
+     * Payload: void
+     */
+    PAUSE = "PLAYCADEMY_PAUSE",
+    /**
+     * Resumes game execution after being paused.
+     * Game should restore timers, animations, and user input.
+     * Payload: void
+     */
+    RESUME = "PLAYCADEMY_RESUME",
+    /**
+     * Forces immediate game termination (emergency exit).
+     * Game should clean up resources and exit immediately.
+     * Payload: void
+     */
+    FORCE_EXIT = "PLAYCADEMY_FORCE_EXIT",
+    /**
+     * Shows or hides UI overlays over the game.
+     * Game may need to pause or adjust rendering accordingly.
+     * Payload: boolean (true = show overlay, false = hide overlay)
+     */
+    OVERLAY = "PLAYCADEMY_OVERLAY",
+    /**
+     * Game has finished loading and is ready to receive messages.
+     * Sent once after game initialization is complete.
+     * Payload: void
+     */
+    READY = "PLAYCADEMY_READY",
+    /**
+     * Game requests to be closed/exited.
+     * Sent when user clicks exit button or game naturally ends.
+     * Payload: void
+     */
+    EXIT = "PLAYCADEMY_EXIT",
+    /**
+     * Game reports performance telemetry data.
+     * Sent periodically for monitoring and analytics.
+     * Payload:
+     * - `fps`: number
+     * - `mem`: number
+     */
+    TELEMETRY = "PLAYCADEMY_TELEMETRY",
+    /**
+     * Game reports key events to parent.
+     * Sent when certain keys are pressed within the game iframe.
+     * Payload:
+     * - `key`: string
+     * - `code?`: string
+     * - `type`: 'keydown' | 'keyup'
+     */
+    KEY_EVENT = "PLAYCADEMY_KEY_EVENT",
+    /**
+     * Notifies about authentication state changes.
+     * Can be sent in both directions depending on auth flow.
+     * Payload:
+     * - `authenticated`: boolean
+     * - `user`: UserInfo | null
+     * - `error`: Error | null
+     */
+    AUTH_STATE_CHANGE = "PLAYCADEMY_AUTH_STATE_CHANGE",
+    /**
+     * OAuth callback data from popup/new-tab windows.
+     * Sent from popup window back to parent after OAuth completes.
+     * Payload:
+     * - `code`: string (OAuth authorization code)
+     * - `state`: string (OAuth state for CSRF protection)
+     * - `error`: string | null (OAuth error if any)
+     */
+    AUTH_CALLBACK = "PLAYCADEMY_AUTH_CALLBACK"
+}
+/**
+ * Type definition for message handler functions.
+ * These functions are called when a specific message type is received.
+ *
+ * @template T - The type of payload data the handler expects
+ * @param payload - The data sent with the message
+ */
+type MessageHandler<T = unknown> = (payload: T) => void;
+/**
+ * Type mapping that defines the payload structure for each message type.
+ * This ensures type safety when sending and receiving messages.
+ *
+ * **Usage Examples**:
+ * ```typescript
+ * // Type-safe message sending
+ * messaging.send(MessageEvents.INIT, { baseUrl: '/api', token: 'abc', gameId: '123' })
+ *
+ * // Type-safe message handling
+ * messaging.listen(MessageEvents.TOKEN_REFRESH, ({ token, exp }) => {
+ *   console.log(`New token expires at: ${new Date(exp)}`)
+ * })
+ * ```
+ */
+type MessageEventMap = {
+    /** Game initialization context with API endpoint, auth token, and game ID */
+    [MessageEvents.INIT]: GameContextPayload;
+    /** Token refresh data with new token and expiration timestamp */
+    [MessageEvents.TOKEN_REFRESH]: TokenRefreshPayload;
+    /** Pause message has no payload data */
+    [MessageEvents.PAUSE]: void;
+    /** Resume message has no payload data */
+    [MessageEvents.RESUME]: void;
+    /** Force exit message has no payload data */
+    [MessageEvents.FORCE_EXIT]: void;
+    /** Overlay visibility state (true = show, false = hide) */
+    [MessageEvents.OVERLAY]: boolean;
+    /** Ready message has no payload data */
+    [MessageEvents.READY]: void;
+    /** Exit message has no payload data */
+    [MessageEvents.EXIT]: void;
+    /** Performance telemetry data */
+    [MessageEvents.TELEMETRY]: TelemetryPayload;
+    /** Key event data */
+    [MessageEvents.KEY_EVENT]: KeyEventPayload;
+    /** Authentication state change notification */
+    [MessageEvents.AUTH_STATE_CHANGE]: AuthStateChangePayload;
+    /** OAuth callback data from popup/new-tab windows */
+    [MessageEvents.AUTH_CALLBACK]: AuthCallbackPayload;
+};
+/**
+ * **PlaycademyMessaging Class**
+ *
+ * This is the core messaging system that handles all communication in the Playcademy platform.
+ * It automatically detects the runtime environment and chooses the appropriate transport method.
+ *
+ * **Key Features**:
+ * 1. **Automatic Transport Selection**: Detects iframe vs local context and uses appropriate method
+ * 2. **Type Safety**: Full TypeScript support with payload type checking
+ * 3. **Bidirectional Communication**: Handles both parent→game and game→parent messages
+ * 4. **Event Cleanup**: Proper listener management to prevent memory leaks
+ *
+ * **Transport Methods**:
+ * - **postMessage**: Used for iframe-to-parent communication (production/development)
+ * - **CustomEvent**: Used for local same-context communication (local development)
+ *
+ * **Runtime Detection Logic**:
+ * - If `window.self !== window.top`: We're in an iframe, use postMessage
+ * - If `window.self === window.top`: We're in the same context, use CustomEvent
+ *
+ * **Example Usage**:
+ * ```typescript
+ * // Send a message (automatically chooses transport)
+ * messaging.send(MessageEvents.READY, undefined)
+ *
+ * // Listen for messages (handles both transports)
+ * messaging.listen(MessageEvents.INIT, (payload) => {
+ *   console.log('Game initialized with:', payload)
+ * })
+ *
+ * // Clean up listeners
+ * messaging.unlisten(MessageEvents.INIT, handler)
+ * ```
+ */
+declare class PlaycademyMessaging {
+    /**
+     * Internal storage for message listeners.
+     *
+     * **Structure Explanation**:
+     * - Outer Map: MessageEvents → Map of handlers for that event type
+     * - Inner Map: MessageHandler → Object containing both listener types
+     * - Object: { postMessage: EventListener, customEvent: EventListener }
+     *
+     * **Why Two Listeners Per Handler?**:
+     * Since we don't know at registration time which transport will be used,
+     * we register both a postMessage listener and a CustomEvent listener.
+     * The appropriate one will be triggered based on the runtime context.
+     */
+    private listeners;
+    /**
+     * **Send Message Method**
+     *
+     * Sends a message using the appropriate transport method based on the runtime context.
+     * This is the main public API for sending messages in the Playcademy system.
+     *
+     * **How It Works**:
+     * 1. Analyzes the message type and current runtime context
+     * 2. Determines if we're in an iframe and if this message should use postMessage
+     * 3. Routes to the appropriate transport method (postMessage or CustomEvent)
+     *
+     * **Transport Selection Logic**:
+     * - **postMessage**: Used when game is in iframe and sending to parent, OR when target window is specified
+     * - **CustomEvent**: Used for local/same-context communication
+     *
+     * **Type Safety**:
+     * The generic type parameter `K` ensures that the payload type matches
+     * the expected type for the given message event.
+     *
+     * @template K - The message event type (ensures type safety)
+     * @param type - The message event type to send
+     * @param payload - The data to send with the message (type-checked)
+     * @param options - Optional configuration for message sending
+     *
+     * @example
+     * ```typescript
+     * // Send game ready signal (no payload)
+     * messaging.send(MessageEvents.READY, undefined)
+     *
+     * // Send telemetry data (typed payload)
+     * messaging.send(MessageEvents.TELEMETRY, { fps: 60, mem: 128 })
+     *
+     * // Send to specific iframe window (parent to iframe communication)
+     * messaging.send(MessageEvents.INIT, { baseUrl, token, gameId }, {
+     *   target: iframe.contentWindow,
+     *   origin: '*'
+     * })
+     *
+     * // TypeScript will error if payload type is wrong
+     * messaging.send(MessageEvents.INIT, "wrong type") // ❌ Error
+     * ```
+     */
+    send<K extends MessageEvents>(type: K, payload: MessageEventMap[K], options?: {
+        target?: Window;
+        origin?: string;
+    }): void;
+    /**
+     * **Listen for Messages Method**
+     *
+     * Registers a message listener that will be called when the specified message type is received.
+     * This method automatically handles both postMessage and CustomEvent sources.
+     *
+     * **Why Register Two Listeners?**:
+     * Since we don't know at registration time which transport method will be used to send
+     * messages, we register listeners for both possible sources:
+     * 1. **postMessage listener**: Handles messages from iframe-to-parent communication
+     * 2. **CustomEvent listener**: Handles messages from local same-context communication
+     *
+     * **Message Processing**:
+     * - **postMessage**: Extracts data from `event.data.payload` or `event.data`
+     * - **CustomEvent**: Extracts data from `event.detail`
+     *
+     * **Type Safety**:
+     * The handler function receives the correctly typed payload based on the message type.
+     *
+     * @template K - The message event type (ensures type safety)
+     * @param type - The message event type to listen for
+     * @param handler - Function to call when the message is received
+     *
+     * @example
+     * ```typescript
+     * // Listen for game initialization
+     * messaging.listen(MessageEvents.INIT, (payload) => {
+     *   // payload is automatically typed as GameContextPayload
+     *   console.log(`Game ${payload.gameId} initialized`)
+     *   console.log(`API base URL: ${payload.baseUrl}`)
+     * })
+     *
+     * // Listen for token refresh
+     * messaging.listen(MessageEvents.TOKEN_REFRESH, ({ token, exp }) => {
+     *   // payload is automatically typed as { token: string; exp: number }
+     *   updateAuthToken(token)
+     *   scheduleTokenRefresh(exp)
+     * })
+     * ```
+     */
+    listen<K extends MessageEvents>(type: K, handler: MessageHandler<MessageEventMap[K]>): void;
+    /**
+     * **Remove Message Listener Method**
+     *
+     * Removes a previously registered message listener to prevent memory leaks and unwanted callbacks.
+     * This method cleans up both the postMessage and CustomEvent listeners that were registered.
+     *
+     * **Why Clean Up Both Listeners?**:
+     * When we registered the listener with `listen()`, we created two browser event listeners:
+     * 1. A 'message' event listener for postMessage communication
+     * 2. A custom event listener for local CustomEvent communication
+     *
+     * Both must be removed to prevent memory leaks and ensure the handler is completely unregistered.
+     *
+     * **Memory Management**:
+     * - Removes both event listeners from the browser
+     * - Cleans up internal tracking maps
+     * - If no more handlers exist for a message type, removes the entire type entry
+     *
+     * **Safe to Call Multiple Times**:
+     * This method is idempotent - calling it multiple times with the same handler is safe.
+     *
+     * @template K - The message event type (ensures type safety)
+     * @param type - The message event type to stop listening for
+     * @param handler - The exact handler function that was passed to listen()
+     *
+     * @example
+     * ```typescript
+     * // Register a handler
+     * const handleInit = (payload) => console.log('Game initialized')
+     * messaging.listen(MessageEvents.INIT, handleInit)
+     *
+     * // Later, remove the handler
+     * messaging.unlisten(MessageEvents.INIT, handleInit)
+     *
+     * // Safe to call multiple times
+     * messaging.unlisten(MessageEvents.INIT, handleInit) // No error
+     * ```
+     */
+    unlisten<K extends MessageEvents>(type: K, handler: MessageHandler<MessageEventMap[K]>): void;
+    /**
+     * **Get Messaging Context Method**
+     *
+     * Analyzes the current runtime environment and message type to determine the appropriate
+     * transport method and configuration for sending messages.
+     *
+     * **Runtime Environment Detection**:
+     * The method detects whether the code is running in an iframe by comparing:
+     * - `window.self`: Reference to the current window
+     * - `window.top`: Reference to the topmost window in the hierarchy
+     *
+     * If they're different, we're in an iframe. If they're the same, we're in the top-level window.
+     *
+     * **Message Direction Analysis**:
+     * Different message types flow in different directions:
+     * - **Game → Parent**: READY, EXIT, TELEMETRY (use postMessage when in iframe)
+     * - **Parent → Game**: INIT, TOKEN_REFRESH, PAUSE, etc. (use CustomEvent in local dev, or postMessage with target)
+     *
+     * **Cross-Context Communication**:
+     * The messaging system supports cross-context targeting through the optional `target` parameter.
+     * When a target window is specified, postMessage is used regardless of the current context.
+     * This enables parent-to-iframe communication through the unified messaging API.
+     *
+     * **Transport Selection Logic**:
+     * - **postMessage**: Used when game is in iframe AND sending to parent, OR when target window is specified
+     * - **CustomEvent**: Used for all other cases (local development, same-context communication)
+     *
+     * **Security Considerations**:
+     * The origin is currently set to '*' for development convenience, but should be
+     * configurable for production security.
+     *
+     * @param eventType - The message event type being sent
+     * @returns Configuration object with transport method and target information
+     *
+     * @example
+     * ```typescript
+     * // In iframe sending READY to parent
+     * const context = getMessagingContext(MessageEvents.READY)
+     * // Returns: { shouldUsePostMessage: true, target: window.parent, origin: '*' }
+     *
+     * // In same context sending INIT
+     * const context = getMessagingContext(MessageEvents.INIT)
+     * // Returns: { shouldUsePostMessage: false, target: undefined, origin: '*' }
+     * ```
+     */
+    private getMessagingContext;
+    /**
+     * **Send Via PostMessage Method**
+     *
+     * Sends a message using the browser's postMessage API for iframe-to-parent communication.
+     * This method is used when the game is running in an iframe and needs to communicate
+     * with the parent window (the Playcademy shell).
+     *
+     * **PostMessage Protocol**:
+     * The postMessage API is the standard way for iframes to communicate with their parent.
+     * It's secure, cross-origin capable, and designed specifically for this use case.
+     *
+     * **Message Structure**:
+     * The method creates a message object with the following structure:
+     * - `type`: The message event type (e.g., 'PLAYCADEMY_READY')
+     * - `payload`: The message data (if any)
+     *
+     * **Payload Handling**:
+     * - **All payloads**: Wrapped in a `payload` property for consistency (e.g., { type, payload: data })
+     * - **Undefined payloads**: Only the type is sent (e.g., { type })
+     *
+     * **Security**:
+     * The origin parameter controls which domains can receive the message.
+     * Currently set to '*' for development, but should be restricted in production.
+     *
+     * @template K - The message event type (ensures type safety)
+     * @param type - The message event type to send
+     * @param payload - The data to send with the message
+     * @param target - The target window (defaults to parent window)
+     * @param origin - The allowed origin for the message (defaults to '*')
+     *
+     * @example
+     * ```typescript
+     * // Send ready signal (no payload)
+     * sendViaPostMessage(MessageEvents.READY, undefined)
+     * // Sends: { type: 'PLAYCADEMY_READY' }
+     *
+     * // Send telemetry data (object payload)
+     * sendViaPostMessage(MessageEvents.TELEMETRY, { fps: 60, mem: 128 })
+     * // Sends: { type: 'PLAYCADEMY_TELEMETRY', payload: { fps: 60, mem: 128 } }
+     *
+     * // Send overlay state (primitive payload)
+     * sendViaPostMessage(MessageEvents.OVERLAY, true)
+     * // Sends: { type: 'PLAYCADEMY_OVERLAY', payload: true }
+     * ```
+     */
+    private sendViaPostMessage;
+    /**
+     * **Send Via CustomEvent Method**
+     *
+     * Sends a message using the browser's CustomEvent API for local same-context communication.
+     * This method is used when both the sender and receiver are in the same window context,
+     * typically during local development or when the parent needs to send messages to the game.
+     *
+     * **CustomEvent Protocol**:
+     * CustomEvent is a browser API for creating and dispatching custom events within the same
+     * window context. It's simpler than postMessage but only works within the same origin/context.
+     *
+     * **Event Structure**:
+     * - **type**: The event name (e.g., 'PLAYCADEMY_INIT')
+     * - **detail**: The payload data attached to the event
+     *
+     * **When This Is Used**:
+     * - Local development when game and shell run in the same context
+     * - Parent-to-game communication (INIT, TOKEN_REFRESH, PAUSE, etc.)
+     * - Any scenario where postMessage isn't needed
+     *
+     * **Event Bubbling**:
+     * CustomEvents are dispatched on the window object and can be listened to by any
+     * code in the same context using `addEventListener(type, handler)`.
+     *
+     * @template K - The message event type (ensures type safety)
+     * @param type - The message event type to send (becomes the event name)
+     * @param payload - The data to send with the message (stored in event.detail)
+     *
+     * @example
+     * ```typescript
+     * // Send initialization data
+     * sendViaCustomEvent(MessageEvents.INIT, {
+     *   baseUrl: '/api',
+     *   token: 'abc123',
+     *   gameId: 'game-456'
+     * })
+     * // Creates: CustomEvent('PLAYCADEMY_INIT', { detail: { baseUrl, token, gameId } })
+     *
+     * // Send pause signal
+     * sendViaCustomEvent(MessageEvents.PAUSE, undefined)
+     * // Creates: CustomEvent('PLAYCADEMY_PAUSE', { detail: undefined })
+     *
+     * // Listeners can access the data via event.detail:
+     * window.addEventListener('PLAYCADEMY_INIT', (event) => {
+     *   console.log(event.detail.gameId) // 'game-456'
+     * })
+     * ```
+     */
+    private sendViaCustomEvent;
+}
+/**
+ * **Playcademy Messaging Singleton**
+ *
+ * This is the main messaging instance used throughout the Playcademy platform.
+ * It's exported as a singleton to ensure consistent communication across all parts
+ * of the application.
+ *
+ * **Why a Singleton?**:
+ * - Ensures all parts of the app use the same messaging instance
+ * - Prevents conflicts between multiple messaging systems
+ * - Simplifies the API - no need to pass instances around
+ * - Maintains consistent event listener management
+ *
+ * **Usage in Different Contexts**:
+ *
+ * **In Games**:
+ * ```typescript
+ * import { messaging, MessageEvents } from '@playcademy/sdk'
+ *
+ * // Tell parent we're ready
+ * messaging.send(MessageEvents.READY, undefined)
+ *
+ * // Listen for pause/resume
+ * messaging.listen(MessageEvents.PAUSE, () => game.pause())
+ * messaging.listen(MessageEvents.RESUME, () => game.resume())
+ * ```
+ *
+ * **In Parent Shell**:
+ * ```typescript
+ * import { messaging, MessageEvents } from '@playcademy/sdk'
+ *
+ * // Send initialization data to game
+ * messaging.send(MessageEvents.INIT, { baseUrl, token, gameId })
+ *
+ * // Listen for game events
+ * messaging.listen(MessageEvents.EXIT, () => closeGame())
+ * messaging.listen(MessageEvents.READY, () => showGame())
+ * ```
+ *
+ * **Automatic Transport Selection**:
+ * The messaging system automatically chooses the right transport method:
+ * - Uses postMessage when game is in iframe sending to parent
+ * - Uses CustomEvent for local development and parent-to-game communication
  *
- * This file serves as the primary entry point for the Playcademy SDK,
- * providing access to the main client class and supporting utilities.
+ * **Type Safety**:
+ * All message sending and receiving is fully type-safe with TypeScript.
  */
-export { PlaycademyClient } from './core/client';
-export { messaging, MessageEvents } from './messaging';
-export { AuthProvider } from './types';
-export type { DevUploadEvent, DevUploadHooks } from './types';
+declare const messaging: PlaycademyMessaging;
+
+export { AuthProvider, BADGES, CURRENCIES, MessageEvents, PlaycademyClient, messaging };
+export type { DevUploadEvent, DevUploadHooks };