@playcademy/sdk 0.0.1-beta.24 → 0.0.1-beta.26

package/README.md

@@ -36,7 +36,9 @@ const client = await initFromWindow() // initFromWindow is async
 For server-side code, UI applications, or other environments where you manage configuration manually:
 
 ```ts
-import { PlaycademyClient, type LoginResponse } from '@playcademy/sdk'
+import { PlaycademyClient } from '@playcademy/sdk'
+
+import type { LoginResponse } from '@playcademy/sdk'
 
 async function initializeAndUseClient() {
     const baseUrl = 'https://api.playcademy.com' // Or your local /api endpoint
@@ -44,11 +46,7 @@ async function initializeAndUseClient() {
 
     try {
         // 1. Authenticate to get a token
-        loginResponse = await PlaycademyClient.login(
-            baseUrl,
-            'user@example.com',
-            'password',
-        )
+        loginResponse = await PlaycademyClient.login(baseUrl, 'user@example.com', 'password')
     } catch (error) {
         console.error('Login failed:', error)
         return

package/dist/core/client.d.ts

@@ -1,6 +1,6 @@
-import { type Method } from './request';
 import { init, login } from './static';
 import type { ClientConfig, ClientEvents } from '../types';
+import type { Method } from './request';
 /**
  * Main Playcademy SDK client for interacting with the platform API.
  * Provides namespaced access to all platform features including games, users, inventory, and more.
@@ -90,24 +90,27 @@ export declare class PlaycademyClient {
     runtime: {
         getGameToken: (gameId: string, options?: {
             apply?: boolean;
-        }) => Promise<import("..").GameTokenResponse>;
+        }) => Promise<import("../types").GameTokenResponse>;
         exit: () => Promise<void>;
     };
     /** Game management methods (fetch, list, saveState, loadState, sessions) */
     games: {
-        fetch: (gameIdOrSlug: string) => Promise<import("@playcademy/types").GameWithManifest>;
-        list: () => Promise<Array<import("@playcademy/types").Game>>;
+        fetch: (gameIdOrSlug: string) => Promise<import("@playcademy/data/types").GameWithManifest>;
+        list: () => Promise<Array<import("@playcademy/data/types").Game>>;
         saveState: (state: Record<string, unknown>) => Promise<void>;
-        loadState: () => Promise<import("..").GameState>;
-        startSession: (gameId?: string) => Promise<import("..").StartSessionResponse>;
+        loadState: () => Promise<{
+            data: unknown;
+            updatedAt: Date | null;
+            userId: string;
+            gameId: string;
+        }>;
+        startSession: (gameId?: string) => Promise<import("../types").StartSessionResponse>;
         endSession: (sessionId: string, gameId?: string) => Promise<void>;
     };
     /** User methods (me, inventory management) */
     users: {
         me: () => Promise<{
             id: string;
-            createdAt: Date;
-            updatedAt: Date;
             name: string;
             username: string | null;
             email: string;
@@ -115,11 +118,13 @@ export declare class PlaycademyClient {
             image: string | null;
             role: "admin" | "player" | "developer";
             developerStatus: "none" | "pending" | "approved";
+            createdAt: Date;
+            updatedAt: Date;
         }>;
         inventory: {
-            get: () => Promise<import("@playcademy/types").InventoryItemWithItem[]>;
-            add: (identifier: string, qty: number) => Promise<import("..").InventoryMutationResponse>;
-            remove: (identifier: string, qty: number) => Promise<import("..").InventoryMutationResponse>;
+            get: () => Promise<import("@playcademy/data/types").InventoryItemWithItem[]>;
+            add: (identifier: string, qty: number) => Promise<import("../types").InventoryMutationResponse>;
+            remove: (identifier: string, qty: number) => Promise<import("../types").InventoryMutationResponse>;
             quantity: (identifier: string) => Promise<number>;
             has: (identifier: string, minQuantity?: number) => Promise<boolean>;
         };
@@ -128,22 +133,22 @@ export declare class PlaycademyClient {
     dev: {
         auth: {
             applyForDeveloper: () => Promise<void>;
-            getDeveloperStatus: () => Promise<import("..").DeveloperStatusValue>;
+            getDeveloperStatus: () => Promise<import("@playcademy/data/types").DeveloperStatusValue>;
         };
         games: {
-            upsert: (slug: string, metadata: import("@playcademy/types").UpsertGameMetadataInput, file: File | Blob) => Promise<import("@playcademy/types").Game>;
-            update: (gameId: string, props: Partial<import("@playcademy/types").Game>) => Promise<void>;
+            upsert: (slug: string, metadata: import("@playcademy/data/types").UpsertGameMetadataInput, file: File | Blob) => Promise<import("@playcademy/data/types").Game>;
+            update: (gameId: string, props: Partial<import("@playcademy/data/types").Game>) => Promise<void>;
             delete: (gameId: string) => Promise<void>;
         };
         keys: {
-            createKey: (gameId: string, label?: string) => Promise<{
+            createKey: (label?: string) => Promise<{
                 id: string;
                 createdAt: Date;
                 userId: string;
                 label: string | null;
                 keyHash: string;
             }>;
-            listKeys: (gameId: string) => Promise<{
+            listKeys: () => Promise<{
                 id: string;
                 createdAt: Date;
                 userId: string;
@@ -152,21 +157,32 @@ export declare class PlaycademyClient {
             }[]>;
             revokeKey: (keyId: string) => Promise<void>;
         };
+        items: {
+            create: (gameId: string, slug: string, itemData: Omit<import("@playcademy/data/types").InsertItemInput, "slug" | "gameId">) => Promise<import("@playcademy/data/types").Item>;
+            update: (gameId: string, itemId: string, updates: import("@playcademy/data/types").UpdateItemInput) => Promise<import("@playcademy/data/types").Item>;
+            list: (gameId: string) => Promise<Array<import("@playcademy/data/types").Item>>;
+            get: (gameId: string, slug: string) => Promise<import("@playcademy/data/types").Item>;
+            delete: (gameId: string, itemId: string) => Promise<void>;
+            shop: {
+                create: (gameId: string, itemId: string, listingData: Omit<import("@playcademy/data/types").InsertShopListingInput, "itemId">) => Promise<import("@playcademy/data/types").ShopListing>;
+                get: (gameId: string, itemId: string) => Promise<import("@playcademy/data/types").ShopListing | null>;
+                update: (gameId: string, itemId: string, updates: import("@playcademy/data/types").UpdateShopListingInput) => Promise<import("@playcademy/data/types").ShopListing>;
+                delete: (gameId: string, itemId: string) => Promise<void>;
+                list: (gameId: string) => Promise<Array<import("@playcademy/data/types").ShopListing & {
+                    item: import("@playcademy/data/types").Item;
+                }>>;
+            };
+        };
     };
     /** Map methods (elements) */
     maps: {
         elements: (mapId: string) => Promise<{
             id: string;
-            metadata: ({
-                description?: string | undefined;
-                sourceTiledObjects?: Record<string, unknown>[] | undefined;
-            } & {
-                [k: string]: unknown;
-            }) | null;
-            gameId: string | null;
             mapId: string | null;
             elementSlug: string;
-            interactionType: "game_entry" | "game_registry" | "info" | "teleport" | "door_in" | "door_out" | "npc_interaction" | "quest_trigger";
+            interactionType: "info" | "game_entry" | "game_registry" | "teleport" | "door_in" | "door_out" | "npc_interaction" | "quest_trigger";
+            metadata: Record<string, unknown> | null;
+            gameId: string | null;
         }[]>;
     };
     /** Admin methods (games, items, currencies, shop listings) */
@@ -176,50 +192,54 @@ export declare class PlaycademyClient {
             resumeGame: (gameId: string) => Promise<void>;
         };
         items: {
-            create: (props: import("@playcademy/types").InsertItem) => Promise<{
+            create: (props: import("@playcademy/data/types").InsertItemInput) => Promise<{
                 id: string;
-                displayName: string;
-                metadata: unknown;
                 createdAt: Date;
-                internalName: string;
+                displayName: string;
                 description: string | null;
+                slug: string;
+                metadata: unknown;
+                gameId: string | null;
                 type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "other";
                 imageUrl: string | null;
             }>;
             get: (itemId: string) => Promise<{
                 id: string;
-                displayName: string;
-                metadata: unknown;
                 createdAt: Date;
-                internalName: string;
+                displayName: string;
                 description: string | null;
+                slug: string;
+                metadata: unknown;
+                gameId: string | null;
                 type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "other";
                 imageUrl: string | null;
             }>;
             list: () => Promise<{
                 id: string;
-                displayName: string;
-                metadata: unknown;
                 createdAt: Date;
-                internalName: string;
+                displayName: string;
                 description: string | null;
+                slug: string;
+                metadata: unknown;
+                gameId: string | null;
                 type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "other";
                 imageUrl: string | null;
             }[]>;
-            update: (itemId: string, props: import("@playcademy/types").UpdateItem) => Promise<{
+            update: (itemId: string, props: import("@playcademy/data/types").UpdateItemInput) => Promise<{
                 id: string;
-                displayName: string;
-                metadata: unknown;
                 createdAt: Date;
-                internalName: string;
+                displayName: string;
                 description: string | null;
+                slug: string;
+                metadata: unknown;
+                gameId: string | null;
                 type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "other";
                 imageUrl: string | null;
             }>;
             delete: (itemId: string) => Promise<void>;
         };
         currencies: {
-            create: (props: import("@playcademy/types").InsertCurrency) => Promise<{
+            create: (props: import("@playcademy/data/types").InsertCurrencyInput) => Promise<{
                 symbol: string | null;
                 id: string;
                 createdAt: Date;
@@ -243,7 +263,7 @@ export declare class PlaycademyClient {
                 itemId: string;
                 isPrimary: boolean;
             }[]>;
-            update: (currencyId: string, props: import("@playcademy/types").UpdateCurrency) => Promise<{
+            update: (currencyId: string, props: import("@playcademy/data/types").UpdateCurrencyInput) => Promise<{
                 symbol: string | null;
                 id: string;
                 createdAt: Date;
@@ -254,7 +274,7 @@ export declare class PlaycademyClient {
             delete: (currencyId: string) => Promise<void>;
         };
         shopListings: {
-            create: (props: import("@playcademy/types").InsertShopListing) => Promise<{
+            create: (props: import("@playcademy/data/types").InsertShopListingInput) => Promise<{
                 id: string;
                 createdAt: Date;
                 updatedAt: Date | null;
@@ -293,7 +313,7 @@ export declare class PlaycademyClient {
                 availableFrom: Date | null;
                 availableUntil: Date | null;
             }[]>;
-            update: (listingId: string, props: import("@playcademy/types").UpdateShopListing) => Promise<{
+            update: (listingId: string, props: import("@playcademy/data/types").UpdateShopListingInput) => Promise<{
                 id: string;
                 createdAt: Date;
                 updatedAt: Date | null;
@@ -311,21 +331,21 @@ export declare class PlaycademyClient {
     };
     /** Shop methods (view) */
     shop: {
-        view: () => Promise<import("..").ShopViewResponse>;
+        view: () => Promise<import("@playcademy/data/types").ShopViewResponse>;
     };
     /** Level methods (levels) */
     levels: {
-        get: () => Promise<import("@playcademy/types").UserLevel>;
+        get: () => Promise<import("@playcademy/data/types").UserLevel>;
         progress: () => Promise<{
             level: number;
             currentXp: number;
             xpToNextLevel: number;
             totalXP: number;
         }>;
-        addXP: (amount: number) => Promise<import("@playcademy/types").XPAddResult>;
+        addXP: (amount: number) => Promise<import("@playcademy/data/types").XPAddResult>;
         config: {
-            list: () => Promise<import("@playcademy/types").LevelConfig[]>;
-            get: (level: number) => Promise<import("@playcademy/types").LevelConfig | null>;
+            list: () => Promise<import("@playcademy/data/types").LevelConfig[]>;
+            get: (level: number) => Promise<import("@playcademy/data/types").LevelConfig | null>;
         };
     };
     /** Telemetry methods (pushMetrics) */

package/dist/core/namespaces/admin.d.ts

@@ -1,5 +1,5 @@
-import type { PlaycademyClient } from '../client';
-import type { InsertItem, UpdateItem, InsertCurrency, UpdateCurrency, InsertShopListing, UpdateShopListing } from '../../types';
+import type { InsertCurrencyInput, InsertItemInput, InsertShopListingInput, UpdateCurrencyInput, UpdateItemInput, UpdateShopListingInput } from '@playcademy/data/types';
+import type { PlaycademyClient } from '../../types';
 /**
  * Creates the admin namespace for the PlaycademyClient.
  * Provides administrative methods for managing games, items, currencies, and shop listings.
@@ -59,13 +59,14 @@ export declare function createAdminNamespace(client: PlaycademyClient): {
          * })
          * ```
          */
-        create: (props: InsertItem) => Promise<{
+        create: (props: InsertItemInput) => Promise<{
             id: string;
-            displayName: string;
-            metadata: unknown;
             createdAt: Date;
-            internalName: string;
+            displayName: string;
             description: string | null;
+            slug: string;
+            metadata: unknown;
+            gameId: string | null;
             type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "other";
             imageUrl: string | null;
         }>;
@@ -83,11 +84,12 @@ export declare function createAdminNamespace(client: PlaycademyClient): {
          */
         get: (itemId: string) => Promise<{
             id: string;
-            displayName: string;
-            metadata: unknown;
             createdAt: Date;
-            internalName: string;
+            displayName: string;
             description: string | null;
+            slug: string;
+            metadata: unknown;
+            gameId: string | null;
             type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "other";
             imageUrl: string | null;
         }>;
@@ -104,11 +106,12 @@ export declare function createAdminNamespace(client: PlaycademyClient): {
          */
         list: () => Promise<{
             id: string;
-            displayName: string;
-            metadata: unknown;
             createdAt: Date;
-            internalName: string;
+            displayName: string;
             description: string | null;
+            slug: string;
+            metadata: unknown;
+            gameId: string | null;
             type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "other";
             imageUrl: string | null;
         }[]>;
@@ -126,13 +129,14 @@ export declare function createAdminNamespace(client: PlaycademyClient): {
          * })
          * ```
          */
-        update: (itemId: string, props: UpdateItem) => Promise<{
+        update: (itemId: string, props: UpdateItemInput) => Promise<{
             id: string;
-            displayName: string;
-            metadata: unknown;
             createdAt: Date;
-            internalName: string;
+            displayName: string;
             description: string | null;
+            slug: string;
+            metadata: unknown;
+            gameId: string | null;
             type: "currency" | "badge" | "trophy" | "collectible" | "consumable" | "unlock" | "upgrade" | "other";
             imageUrl: string | null;
         }>;
@@ -169,7 +173,7 @@ export declare function createAdminNamespace(client: PlaycademyClient): {
          * })
          * ```
          */
-        create: (props: InsertCurrency) => Promise<{
+        create: (props: InsertCurrencyInput) => Promise<{
             symbol: string | null;
             id: string;
             createdAt: Date;
@@ -230,7 +234,7 @@ export declare function createAdminNamespace(client: PlaycademyClient): {
          * })
          * ```
          */
-        update: (currencyId: string, props: UpdateCurrency) => Promise<{
+        update: (currencyId: string, props: UpdateCurrencyInput) => Promise<{
             symbol: string | null;
             id: string;
             createdAt: Date;
@@ -271,7 +275,7 @@ export declare function createAdminNamespace(client: PlaycademyClient): {
          * })
          * ```
          */
-        create: (props: InsertShopListing) => Promise<{
+        create: (props: InsertShopListingInput) => Promise<{
             id: string;
             createdAt: Date;
             updatedAt: Date | null;
@@ -347,7 +351,7 @@ export declare function createAdminNamespace(client: PlaycademyClient): {
          * })
          * ```
          */
-        update: (listingId: string, props: UpdateShopListing) => Promise<{
+        update: (listingId: string, props: UpdateShopListingInput) => Promise<{
             id: string;
             createdAt: Date;
             updatedAt: Date | null;

package/dist/core/namespaces/auth.d.ts

@@ -1,4 +1,4 @@
-import type { PlaycademyClient } from '../client';
+import type { PlaycademyClient } from '../../types';
 /**
  * Creates the authentication namespace for the PlaycademyClient.
  * Provides methods for managing user authentication state.

package/dist/core/namespaces/credits.d.ts

@@ -1,4 +1,4 @@
-import type { PlaycademyClient } from '../client';
+import type { PlaycademyClient } from '../../types';
 /**
  * Creates the credits namespace for the PlaycademyClient.
  * Provides convenient methods for working with Playcademy Credits (the primary platform currency).

package/dist/core/namespaces/dev.d.ts

@@ -1,12 +1,11 @@
-import type { PlaycademyClient } from '../client';
-import type { Game, UpsertGameMetadataInput } from '@playcademy/types';
-import type { DeveloperStatusValue } from '../../types';
+import type { DeveloperStatusValue, Game, InsertItemInput, InsertShopListingInput, Item, ShopListing, UpdateItemInput, UpdateShopListingInput, UpsertGameMetadataInput } from '@playcademy/data/types';
+import type { PlaycademyClient } from '../../types';
 /**
  * Creates the developer namespace for the PlaycademyClient.
- * Provides methods for developer account management, game publishing, and API key management.
+ * Provides methods for developer account management, game publishing, API key management, and item management.
  *
  * @param client - The PlaycademyClient instance
- * @returns Developer namespace with auth, games, and keys methods
+ * @returns Developer namespace with auth, games, keys, and items methods
  */
 export declare function createDevNamespace(client: PlaycademyClient): {
     /**
@@ -97,19 +96,18 @@ export declare function createDevNamespace(client: PlaycademyClient): {
      */
     keys: {
         /**
-         * Creates a new API key for a game.
+         * Creates a new API key for the developer.
          *
-         * @param gameId - The game ID to create a key for
          * @param label - Optional label for the key
          * @returns Promise resolving to the created API key
          *
          * @example
          * ```typescript
-         * const key = await client.dev.keys.createKey('game-123', 'Production Key')
-         * console.log('API Key:', key.key)
+         * const key = await client.dev.keys.createKey('Production Key')
+         * console.log('API Key:', key.apiKey)
          * ```
          */
-        createKey: (gameId: string, label?: string) => Promise<{
+        createKey: (label?: string) => Promise<{
             id: string;
             createdAt: Date;
             userId: string;
@@ -117,18 +115,17 @@ export declare function createDevNamespace(client: PlaycademyClient): {
             keyHash: string;
         }>;
         /**
-         * Lists all API keys for a game.
+         * Lists all API keys for the developer.
          *
-         * @param gameId - The game ID to list keys for
          * @returns Promise resolving to array of API keys
          *
          * @example
          * ```typescript
-         * const keys = await client.dev.keys.listKeys('game-123')
-         * keys.forEach(key => console.log(`${key.label}: ${key.key}`))
+         * const keys = await client.dev.keys.listKeys()
+         * keys.forEach(key => console.log(`${key.label}: ${key.id}`))
          * ```
          */
-        listKeys: (gameId: string) => Promise<{
+        listKeys: () => Promise<{
             id: string;
             createdAt: Date;
             userId: string;
@@ -149,4 +146,177 @@ export declare function createDevNamespace(client: PlaycademyClient): {
          */
         revokeKey: (keyId: string) => Promise<void>;
     };
+    /**
+     * Item management methods for developers.
+     * Allows developers to create and manage game-specific items.
+     */
+    items: {
+        /**
+         * Creates a new game-scoped item.
+         *
+         * @param gameId - The game ID to create the item for
+         * @param slug - The item slug (unique within the game)
+         * @param itemData - Item properties (displayName, description, type, etc.)
+         * @returns Promise resolving to the created item
+         *
+         * @example
+         * ```typescript
+         * const item = await client.dev.items.create('game-123', 'MAGIC_SWORD', {
+         *   displayName: 'Magic Sword',
+         *   description: 'A powerful enchanted blade',
+         *   type: 'unlock',
+         *   metadata: { rarity: 'epic' }
+         * })
+         * ```
+         */
+        create: (gameId: string, slug: string, itemData: Omit<InsertItemInput, "slug" | "gameId">) => Promise<Item>;
+        /**
+         * Updates an existing game-scoped item.
+         *
+         * @param gameId - The game ID
+         * @param itemId - The item ID to update
+         * @param updates - Partial item properties to update
+         * @returns Promise resolving to the updated item
+         *
+         * @example
+         * ```typescript
+         * const updated = await client.dev.items.update('game-123', 'item-456', {
+         *   displayName: 'Super Magic Sword',
+         *   metadata: { rarity: 'legendary' }
+         * })
+         * ```
+         */
+        update: (gameId: string, itemId: string, updates: UpdateItemInput) => Promise<Item>;
+        /**
+         * Lists all items for a specific game.
+         *
+         * @param gameId - The game ID to list items for
+         * @returns Promise resolving to array of game-scoped items
+         *
+         * @example
+         * ```typescript
+         * const items = await client.dev.items.list('game-123')
+         * items.forEach(item => console.log(`${item.slug}: ${item.displayName}`))
+         * ```
+         */
+        list: (gameId: string) => Promise<Array<Item>>;
+        /**
+         * Gets a specific item by slug within a game context.
+         * Uses the resolution endpoint to find the item.
+         *
+         * @param gameId - The game ID context
+         * @param slug - The item slug to retrieve
+         * @returns Promise resolving to the item
+         *
+         * @example
+         * ```typescript
+         * const item = await client.dev.items.get('game-123', 'MAGIC_SWORD')
+         * console.log('Item:', item.displayName)
+         * ```
+         */
+        get: (gameId: string, slug: string) => Promise<Item>;
+        /**
+         * Deletes a game-scoped item.
+         *
+         * @param gameId - The game ID
+         * @param itemId - The item ID to delete
+         * @returns Promise that resolves when item is deleted
+         *
+         * @example
+         * ```typescript
+         * await client.dev.items.delete('game-123', 'item-456')
+         * console.log('Item deleted successfully')
+         * ```
+         */
+        delete: (gameId: string, itemId: string) => Promise<void>;
+        /**
+         * Shop listing management for game items.
+         * Allows developers to control if and how their items are sold.
+         */
+        shop: {
+            /**
+             * Creates a shop listing for a game item.
+             *
+             * @param gameId - The game ID
+             * @param itemId - The item ID to list for sale
+             * @param listingData - Shop listing properties (price, currency, etc.)
+             * @returns Promise resolving to the created shop listing
+             *
+             * @example
+             * ```typescript
+             * const listing = await client.dev.items.shop.create('game-123', 'item-456', {
+             *   currencyId: 'credits-currency-id',
+             *   price: 100,
+             *   sellBackPercentage: 50,
+             *   isActive: true
+             * })
+             * ```
+             */
+            create: (gameId: string, itemId: string, listingData: Omit<InsertShopListingInput, "itemId">) => Promise<ShopListing>;
+            /**
+             * Gets the shop listing for a specific game item.
+             *
+             * @param gameId - The game ID
+             * @param itemId - The item ID
+             * @returns Promise resolving to the shop listing, or null if no listing exists
+             *
+             * @example
+             * ```typescript
+             * const listing = await client.dev.items.shop.get('game-123', 'item-456')
+             * if (listing) {
+             *   console.log(`Item is listed for ${listing.price} credits`)
+             * }
+             * ```
+             */
+            get: (gameId: string, itemId: string) => Promise<ShopListing | null>;
+            /**
+             * Updates an existing shop listing for a game item.
+             *
+             * @param gameId - The game ID
+             * @param itemId - The item ID
+             * @param updates - Partial shop listing properties to update
+             * @returns Promise resolving to the updated shop listing
+             *
+             * @example
+             * ```typescript
+             * const updated = await client.dev.items.shop.update('game-123', 'item-456', {
+             *   price: 150,
+             *   isActive: false
+             * })
+             * ```
+             */
+            update: (gameId: string, itemId: string, updates: UpdateShopListingInput) => Promise<ShopListing>;
+            /**
+             * Removes the shop listing for a game item.
+             *
+             * @param gameId - The game ID
+             * @param itemId - The item ID
+             * @returns Promise that resolves when listing is removed
+             *
+             * @example
+             * ```typescript
+             * await client.dev.items.shop.delete('game-123', 'item-456')
+             * console.log('Item removed from shop')
+             * ```
+             */
+            delete: (gameId: string, itemId: string) => Promise<void>;
+            /**
+             * Lists all shop listings for a game.
+             *
+             * @param gameId - The game ID
+             * @returns Promise resolving to array of shop listings for the game
+             *
+             * @example
+             * ```typescript
+             * const listings = await client.dev.items.shop.list('game-123')
+             * listings.forEach(listing => {
+             *   console.log(`${listing.item.displayName}: ${listing.price}`)
+             * })
+             * ```
+             */
+            list: (gameId: string) => Promise<Array<ShopListing & {
+                item: Item;
+            }>>;
+        };
+    };
 };

package/dist/core/namespaces/games.d.ts

@@ -1,6 +1,5 @@
-import type { PlaycademyClient } from '../client';
-import type { Game, GameWithManifest } from '@playcademy/types';
-import type { GameState, StartSessionResponse } from '../../types';
+import type { Game, GameWithManifest } from '@playcademy/data/types';
+import type { PlaycademyClient, StartSessionResponse } from '../../types';
 /**
  * Creates the games namespace for the PlaycademyClient.
  * Provides methods for managing games, game state, and game sessions.
@@ -65,7 +64,12 @@ export declare function createGamesNamespace(client: PlaycademyClient): {
      * console.log('Current level:', state.level)
      * ```
      */
-    loadState: () => Promise<GameState>;
+    loadState: () => Promise<{
+        data: unknown;
+        updatedAt: Date | null;
+        userId: string;
+        gameId: string;
+    }>;
     /**
      * Starts a new game session.
      *