@playcademy/sdk 0.0.1-beta.3 → 0.0.1-beta.30

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

@@ -0,0 +1,183 @@
+import type { InventoryItemWithItem } from '@playcademy/data/types';
+import type { InventoryMutationResponse, PlaycademyClient } from '../../types';
+export interface UserScore {
+    id: string;
+    score: number;
+    achievedAt: Date;
+    metadata?: Record<string, unknown>;
+    gameId: string;
+    gameTitle: string;
+    gameSlug: string;
+}
+/**
+ * Creates the users namespace for the PlaycademyClient.
+ * Provides methods for managing user data and inventory operations.
+ *
+ * @param client - The PlaycademyClient instance
+ * @returns Users namespace with user profile and inventory methods
+ */
+export declare function createUsersNamespace(client: PlaycademyClient): {
+    /**
+     * Retrieves the current user's profile information.
+     *
+     * @returns Promise resolving to user profile data
+     *
+     * @example
+     * ```typescript
+     * const user = await client.users.me()
+     * console.log('Username:', user.username)
+     * console.log('Email:', user.email)
+     * ```
+     */
+    me: () => Promise<{
+        id: string;
+        name: string;
+        username: string | null;
+        email: string;
+        emailVerified: boolean;
+        image: string | null;
+        role: "admin" | "player" | "developer";
+        developerStatus: "none" | "pending" | "approved";
+        characterCreated: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    /**
+     * Inventory management methods for the current user.
+     */
+    inventory: {
+        /**
+         * Retrieves the user's complete inventory.
+         *
+         * @returns Promise resolving to array of inventory items with item details
+         *
+         * @example
+         * ```typescript
+         * const inventory = await client.users.inventory.get()
+         * inventory.forEach(item => {
+         *   console.log(`${item.item.name}: ${item.quantity}`)
+         * })
+         * ```
+         */
+        get: () => Promise<InventoryItemWithItem[]>;
+        /**
+         * Adds items to the user's inventory.
+         * Accepts either an item UUID or slug.
+         * Emits an 'inventoryChange' event when successful.
+         *
+         * @param identifier - The item UUID or slug
+         * @param qty - The quantity to add (must be positive)
+         * @returns Promise resolving to mutation response with new total
+         *
+         * @example
+         * ```typescript
+         * // Using slug
+         * const result = await client.users.inventory.add('gold-coin', 100)
+         *
+         * // Using UUID
+         * const result = await client.users.inventory.add('550e8400-e29b-41d4-a716-446655440000', 100)
+         *
+         * console.log('New total:', result.newTotal)
+         * ```
+         */
+        add: (identifier: string, qty: number) => Promise<InventoryMutationResponse>;
+        /**
+         * Removes items from the user's inventory.
+         * Accepts either an item UUID or slug.
+         * Emits an 'inventoryChange' event when successful.
+         *
+         * @param identifier - The item UUID or slug
+         * @param qty - The quantity to remove (must be positive)
+         * @returns Promise resolving to mutation response with new total
+         *
+         * @example
+         * ```typescript
+         * // Using slug
+         * const result = await client.users.inventory.remove('HEALTH_POTION', 1)
+         *
+         * // Using UUID
+         * const result = await client.users.inventory.remove('uuid-456-789', 1)
+         *
+         * console.log('Remaining:', result.newTotal)
+         * ```
+         */
+        remove: (identifier: string, qty: number) => Promise<InventoryMutationResponse>;
+        /**
+         * Gets the current quantity of an item.
+         * Accepts either an item UUID or slug.
+         *
+         * @param identifier - The item UUID or slug
+         * @returns Promise resolving to the current quantity (0 if not owned)
+         *
+         * @example
+         * ```typescript
+         * const qty = await client.users.inventory.quantity('health-potion')
+         * const qty2 = await client.users.inventory.quantity('uuid-123-456')
+         * console.log('Health potions:', qty)
+         * ```
+         */
+        quantity: (identifier: string) => Promise<number>;
+        /**
+         * Checks if the user has at least the specified quantity of an item.
+         * Accepts either an item UUID or slug.
+         *
+         * @param identifier - The item UUID or slug
+         * @param minQuantity - Minimum quantity required (defaults to 1)
+         * @returns Promise resolving to true if user has enough of the item
+         *
+         * @example
+         * ```typescript
+         * const hasKey = await client.users.inventory.has('gold-coin')
+         * const hasEnoughGold = await client.users.inventory.has('gold-coin', 100)
+         * const hasPotion = await client.users.inventory.has('uuid-123-456', 5)
+         *
+         * if (hasKey && hasEnoughGold) {
+         *   console.log('Can enter premium dungeon!')
+         * }
+         * ```
+         */
+        has: (identifier: string, minQuantity?: number) => Promise<boolean>;
+    };
+    /**
+     * User scores management methods.
+     */
+    scores: {
+        /**
+         * Gets scores for a user across all games.
+         *
+         * @param userIdOrOptions - User ID or options object. If omitted, gets scores for the current user.
+         * @param options - Optional filtering options
+         * @param options.limit - Maximum number of scores to return
+         * @param options.gameId - Filter scores by specific game
+         * @returns Promise resolving to array of user scores
+         *
+         * @example
+         * ```typescript
+         * // Get all scores for current user
+         * const myScores = await client.users.scores.get()
+         *
+         * // Get scores for current user with options
+         * const myGameScores = await client.users.scores.get({
+         *   gameId: 'game-456',
+         *   limit: 20
+         * })
+         *
+         * // Get scores for a specific user
+         * const userScores = await client.users.scores.get('user-123')
+         *
+         * // Get scores for a specific user with options
+         * const userGameScores = await client.users.scores.get('user-123', {
+         *   gameId: 'game-789',
+         *   limit: 10
+         * })
+         * ```
+         */
+        get: (userIdOrOptions?: string | {
+            limit?: number;
+            gameId?: string;
+        }, options?: {
+            limit?: number;
+            gameId?: string;
+        }) => Promise<UserScore[]>;
+    };
+};

package/dist/core/request.d.ts

@@ -1,4 +1,4 @@
-import { type ManifestV1 } from '@playcademy/data/schemas';
+import type { ManifestV1 } from '@playcademy/data/types';
 /** Permitted HTTP verbs */
 export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 export interface RequestOptions {

package/dist/core/static/index.d.ts

@@ -0,0 +1,2 @@
+export { init } from './init';
+export { login } from './login';

package/dist/core/static/init.d.ts

@@ -0,0 +1,21 @@
+import type { PlaycademyClient } from '../../types';
+/**
+ * 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()
+ * ```
+ */
+export declare function init(): Promise<PlaycademyClient>;

package/dist/core/static/login.d.ts

@@ -0,0 +1,24 @@
+import type { LoginResponse } from '../../types';
+/**
+ * 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.
+ *
+ * @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
+ * 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)
+ * }
+ * ```
+ */
+export declare function login(baseUrl: string, email: string, password: string): Promise<LoginResponse>;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Playcademy SDK - Main Entry Point
+ *
+ * This file serves as the primary entry point for the Playcademy SDK,
+ * providing access to the main client class and supporting utilities.
+ */
+export { PlaycademyClient } from './core/client';
+export { messaging, MessageEvents } from './messaging';