@kokimoki/app 2.0.0 → 2.0.1

package/dist/services/kokimoki-ai.js

@@ -0,0 +1,164 @@
+/**
+ * Kokimoki AI Integration Service
+ *
+ * Provides built-in AI capabilities for game applications without requiring API keys or setup.
+ * Includes text generation, structured JSON output, and image modification.
+ *
+ * **Key Features:**
+ * - Multiple AI models (GPT-4, GPT-5, Gemini variants)
+ * - Text generation with configurable creativity (temperature)
+ * - Structured JSON output for game data
+ * - AI-powered image modifications
+ * - No API keys or configuration required
+ *
+ * **Common Use Cases:**
+ * - Generate dynamic game content (quests, dialogues, stories)
+ * - Create AI opponents or NPCs with personalities
+ * - Generate quiz questions or trivia
+ * - Create game assets (character stats, item descriptions)
+ * - Transform user-uploaded images
+ * - Generate procedural content
+ *
+ * Access via `kmClient.ai`
+ *
+ * @example
+ * ```typescript
+ * // Generate story text
+ * const story = await kmClient.ai.chat({
+ *   systemPrompt: 'You are a fantasy story writer',
+ *   userPrompt: 'Write a short quest description',
+ *   temperature: 0.8
+ * });
+ *
+ * // Generate structured game data
+ * interface Enemy {
+ *   name: string;
+ *   health: number;
+ *   attack: number;
+ * }
+ * const enemy = await kmClient.ai.generateJson<Enemy>({
+ *   userPrompt: 'Create a level 5 goblin warrior'
+ * });
+ *
+ * // Transform image
+ * const modified = await kmClient.ai.modifyImage(
+ *   imageUrl,
+ *   'Make it look like pixel art'
+ * );
+ * ```
+ */
+export class KokimokiAiService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Generate a chat response from the AI model.
+     *
+     * Sends a chat request to the AI service and returns the generated response.
+     * Supports multiple AI models including GPT and Gemini variants with configurable
+     * parameters for fine-tuning the response behavior.
+     *
+     * @param req The chat request parameters.
+     * @param req.model Optional. The AI model to use. Defaults to server-side default if not specified.
+     *                  Available models:
+     *                  - `gpt-4o`: OpenAI GPT-4 Optimized
+     *                  - `gpt-4o-mini`: Smaller, faster GPT-4 variant
+     *                  - `gpt-5`: OpenAI GPT-5 (latest)
+     *                  - `gpt-5-mini`: Smaller GPT-5 variant
+     *                  - `gpt-5-nano`: Smallest GPT-5 variant for lightweight tasks
+     *                  - `gemini-2.5-flash-lite`: Google Gemini lite variant
+     *                  - `gemini-2.5-flash`: Google Gemini fast variant
+     * @param req.systemPrompt Optional. The system message that sets the behavior and context for the AI.
+     *                         This helps define the AI's role, personality, and constraints.
+     * @param req.userPrompt The user's message or question to send to the AI.
+     * @param req.temperature Optional. Controls randomness in the response (0.0 to 1.0).
+     *                        Lower values make output more focused and deterministic,
+     *                        higher values make it more creative and varied.
+     * @param req.maxTokens Optional. The maximum number of tokens to generate in the response.
+     *                      Controls the length of the AI's output.
+     *
+     * @returns A promise that resolves to an object containing the AI-generated response.
+     * @returns {string} content The text content of the AI's response.
+     *
+     * @throws An error object if the API request fails.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.ai.chat({
+     *   model: "gpt-4o",
+     *   systemPrompt: "You are a helpful coding assistant.",
+     *   userPrompt: "Explain what TypeScript is in one sentence.",
+     *   temperature: 0.7,
+     *   maxTokens: 100
+     * });
+     * console.log(response.content);
+     * ```
+     */
+    async chat(req) {
+        const res = await fetch(`${this.client.apiUrl}/ai/chat`, {
+            method: "POST",
+            headers: this.client.apiHeaders,
+            body: JSON.stringify(req),
+        });
+        if (!res.ok) {
+            throw await res.json();
+        }
+        return await res.json();
+    }
+    /**
+     * Generate structured JSON output from the AI model.
+     *
+     * Sends a chat request to the AI service with the expectation of receiving
+     * a JSON-formatted response. This is useful for scenarios where the output
+     * needs to be parsed or processed programmatically.
+     *
+     * @param req The chat request parameters.
+     * @param req.model Optional. The AI model to use. Defaults to server-side default if not specified.
+     *                  Available models:
+     *                  - `gpt-4o`: OpenAI GPT-4 Optimized
+     *                  - `gpt-4o-mini`: Smaller, faster GPT-4 variant
+     *                  - `gpt-5`: OpenAI GPT-5 (latest)
+     *                  - `gpt-5-mini`: Smaller GPT-5 variant
+     *                  - `gpt-5-nano`: Smallest GPT-5 variant for lightweight tasks
+     *                  - `gemini-2.5-flash-lite`: Google Gemini lite variant
+     *                  - `gemini-2.5-flash`: Google Gemini fast variant
+     * @param req.systemPrompt Optional. The system message that sets the behavior and context for the AI.
+     *                         This helps define the AI's role, personality, and constraints.
+     * @param req.userPrompt The user's message or question to send to the AI.
+     * @param req.temperature Optional. Controls randomness in the response (0.0 to 1.0).
+     *                        Lower values make output more focused and deterministic,
+     *                        higher values make it more creative and varied.
+     * @param req.maxTokens Optional. The maximum number of tokens to generate in the response.
+     *                      Controls the length of the AI's output.
+     *
+     * @returns A promise that resolves to the parsed JSON object generated by the AI.
+     *
+     * @throws An error object if the API request fails or if the response is not valid JSON.
+     */
+    async generateJson(req) {
+        const { content } = await this.chat({
+            ...req,
+            responseMimeType: "application/json",
+        });
+        return JSON.parse(content);
+    }
+    /**
+     * Modify an image using the AI service.
+     * @param baseImageUrl The URL of the base image to modify.
+     * @param prompt The modification prompt to apply to the image.
+     * @param tags Optional. Tags to associate with the image.
+     * @returns A promise that resolves to the modified image upload information.
+     */
+    async modifyImage(baseImageUrl, prompt, tags = []) {
+        const res = await fetch(`${this.client.apiUrl}/ai/modify-image`, {
+            method: "POST",
+            headers: this.client.apiHeaders,
+            body: JSON.stringify({ baseImageUrl, prompt, tags }),
+        });
+        if (!res.ok) {
+            throw await res.json();
+        }
+        return await res.json();
+    }
+}

package/dist/services/kokimoki-leaderboard.d.ts

@@ -0,0 +1,175 @@
+import { KokimokiClient } from "../core";
+import type { Paginated } from "../types";
+/**
+ * Kokimoki Leaderboard Service
+ *
+ * Provides efficient player ranking and score tracking with database indexes and optimized queries.
+ * Ideal for games with large numbers of players and competitive scoring.
+ *
+ * **Key Features:**
+ * - Efficient ranking with database indexes
+ * - Support for ascending (lowest-is-best) and descending (highest-is-best) sorting
+ * - Pagination for large leaderboards
+ * - Public and private metadata for entries
+ * - Insert (preserve all attempts) or upsert (keep latest only) modes
+ *
+ * **When to use Leaderboard API vs Global Store:**
+ *
+ * Use the **Leaderboard API** when:
+ * - You have a large number of entries (hundreds to thousands of players)
+ * - You need efficient ranking and sorting with database indexes
+ * - You want pagination and optimized queries for top scores
+ * - Memory and network efficiency are important
+ *
+ * Use a **Global Store** when:
+ * - You have a small number of players (typically under 100)
+ * - You need real-time updates and live leaderboard changes
+ * - You want to combine player scores with other game state
+ * - The leaderboard is temporary (session-based or reset frequently)
+ *
+ * Access via `kmClient.leaderboard`
+ *
+ * @example
+ * ```typescript
+ * // Submit a high score
+ * const { rank } = await kmClient.leaderboard.upsertEntry(
+ *   'high-scores',
+ *   'desc',
+ *   1500,
+ *   { playerName: 'Alice' },
+ *   {}
+ * );
+ *
+ * // Get top 10
+ * const { items } = await kmClient.leaderboard.listEntries('high-scores', 'desc', 0, 10);
+ *
+ * // Get player's best
+ * const best = await kmClient.leaderboard.getBestEntry('high-scores', 'desc');
+ * ```
+ */
+export declare class KokimokiLeaderboardService {
+    private readonly client;
+    constructor(client: KokimokiClient);
+    /**
+     * Add a new entry to a leaderboard.
+     *
+     * Creates a new entry each time it's called, preserving all attempts. Use this when you want
+     * to track every score submission (e.g., all game attempts).
+     *
+     * @param leaderboardName The name of the leaderboard to add the entry to
+     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
+     *                "desc" for highest-is-best (e.g., points)
+     * @param score The numeric score value
+     * @param metadata Public metadata visible to all players (e.g., player name, level)
+     * @param privateMetadata Private metadata only accessible via API calls (e.g., session ID)
+     * @returns A promise resolving to an object with the entry's rank
+     *
+     * @example
+     * ```typescript
+     * const { rank } = await kmClient.leaderboard.insertEntry(
+     *   'high-scores',
+     *   'desc',
+     *   1500,
+     *   { playerName: 'Alice', level: 10 },
+     *   { sessionId: 'abc123' }
+     * );
+     * console.log(`New rank: ${rank}`);
+     * ```
+     */
+    insertEntry<MetadataT, PrivateMetadataT>(leaderboardName: string, sortDir: "asc" | "desc", score: number, metadata: MetadataT, privateMetadata: PrivateMetadataT): Promise<{
+        rank: number;
+    }>;
+    /**
+     * Add or update the latest entry for the current client in a leaderboard.
+     *
+     * Replaces the previous entry if one exists for this client. Use this when you only want
+     * to keep the latest or best score per player (e.g., daily high score).
+     *
+     * @param leaderboardName The name of the leaderboard to upsert the entry in
+     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
+     *                "desc" for highest-is-best (e.g., points)
+     * @param score The numeric score value
+     * @param metadata Public metadata visible to all players (e.g., player name, completion time)
+     * @param privateMetadata Private metadata only accessible via API calls (e.g., device ID)
+     * @returns A promise resolving to an object with the entry's updated rank
+     *
+     * @example
+     * ```typescript
+     * const { rank } = await kmClient.leaderboard.upsertEntry(
+     *   'daily-scores',
+     *   'desc',
+     *   2000,
+     *   { playerName: 'Bob', completionTime: 120 },
+     *   { deviceId: 'xyz789' }
+     * );
+     * console.log(`Updated rank: ${rank}`);
+     * ```
+     */
+    upsertEntry<MetadataT, PrivateMetadataT>(leaderboardName: string, sortDir: "asc" | "desc", score: number, metadata: MetadataT, privateMetadata: PrivateMetadataT): Promise<{
+        rank: number;
+    }>;
+    /**
+     * List entries in a leaderboard with pagination.
+     *
+     * Retrieves a sorted list of leaderboard entries. Use skip and limit parameters for
+     * pagination (e.g., showing top 10, or implementing "load more" functionality).
+     *
+     * @param leaderboardName The name of the leaderboard to query
+     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
+     *                "desc" for highest-is-best (e.g., points)
+     * @param skip Number of entries to skip for pagination (default: 0)
+     * @param limit Maximum number of entries to return (default: 100)
+     * @returns A promise resolving to a paginated list of entries with rank, score, and metadata
+     *
+     * @example
+     * ```typescript
+     * // Get top 10 scores
+     * const { items, total } = await kmClient.leaderboard.listEntries(
+     *   'weekly-scores',
+     *   'desc',
+     *   0,
+     *   10
+     * );
+     *
+     * items.forEach(entry => {
+     *   console.log(`Rank ${entry.rank}: ${entry.metadata.playerName} - ${entry.score}`);
+     * });
+     * ```
+     */
+    listEntries<MetadataT>(leaderboardName: string, sortDir: "asc" | "desc", skip?: number, limit?: number): Promise<Paginated<{
+        rank: number;
+        score: number;
+        metadata: MetadataT;
+    }>>;
+    /**
+     * Get the best entry for a specific client in a leaderboard.
+     *
+     * Retrieves the highest-ranked entry for a client based on the sort direction.
+     * Defaults to the current client if no clientId is provided.
+     *
+     * @param leaderboardName The name of the leaderboard to query
+     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
+     *                "desc" for highest-is-best (e.g., points)
+     * @param clientId The client ID to get the best entry for (optional, defaults to current client)
+     * @returns A promise resolving to the best entry with rank, score, and metadata
+     *
+     * @example
+     * ```typescript
+     * // Get current client's best entry
+     * const myBest = await kmClient.leaderboard.getBestEntry('all-time-high', 'desc');
+     * console.log(`My best: Rank ${myBest.rank}, Score ${myBest.score}`);
+     *
+     * // Get another player's best entry
+     * const otherBest = await kmClient.leaderboard.getBestEntry(
+     *   'all-time-high',
+     *   'desc',
+     *   'other-client-id'
+     * );
+     * ```
+     */
+    getBestEntry<MetadataT>(leaderboardName: string, sortDir: "asc" | "desc", clientId?: string): Promise<{
+        rank: number;
+        score: number;
+        metadata: MetadataT;
+    }>;
+}

package/dist/services/kokimoki-leaderboard.js

@@ -0,0 +1,203 @@
+/**
+ * Kokimoki Leaderboard Service
+ *
+ * Provides efficient player ranking and score tracking with database indexes and optimized queries.
+ * Ideal for games with large numbers of players and competitive scoring.
+ *
+ * **Key Features:**
+ * - Efficient ranking with database indexes
+ * - Support for ascending (lowest-is-best) and descending (highest-is-best) sorting
+ * - Pagination for large leaderboards
+ * - Public and private metadata for entries
+ * - Insert (preserve all attempts) or upsert (keep latest only) modes
+ *
+ * **When to use Leaderboard API vs Global Store:**
+ *
+ * Use the **Leaderboard API** when:
+ * - You have a large number of entries (hundreds to thousands of players)
+ * - You need efficient ranking and sorting with database indexes
+ * - You want pagination and optimized queries for top scores
+ * - Memory and network efficiency are important
+ *
+ * Use a **Global Store** when:
+ * - You have a small number of players (typically under 100)
+ * - You need real-time updates and live leaderboard changes
+ * - You want to combine player scores with other game state
+ * - The leaderboard is temporary (session-based or reset frequently)
+ *
+ * Access via `kmClient.leaderboard`
+ *
+ * @example
+ * ```typescript
+ * // Submit a high score
+ * const { rank } = await kmClient.leaderboard.upsertEntry(
+ *   'high-scores',
+ *   'desc',
+ *   1500,
+ *   { playerName: 'Alice' },
+ *   {}
+ * );
+ *
+ * // Get top 10
+ * const { items } = await kmClient.leaderboard.listEntries('high-scores', 'desc', 0, 10);
+ *
+ * // Get player's best
+ * const best = await kmClient.leaderboard.getBestEntry('high-scores', 'desc');
+ * ```
+ */
+export class KokimokiLeaderboardService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Add a new entry to a leaderboard.
+     *
+     * Creates a new entry each time it's called, preserving all attempts. Use this when you want
+     * to track every score submission (e.g., all game attempts).
+     *
+     * @param leaderboardName The name of the leaderboard to add the entry to
+     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
+     *                "desc" for highest-is-best (e.g., points)
+     * @param score The numeric score value
+     * @param metadata Public metadata visible to all players (e.g., player name, level)
+     * @param privateMetadata Private metadata only accessible via API calls (e.g., session ID)
+     * @returns A promise resolving to an object with the entry's rank
+     *
+     * @example
+     * ```typescript
+     * const { rank } = await kmClient.leaderboard.insertEntry(
+     *   'high-scores',
+     *   'desc',
+     *   1500,
+     *   { playerName: 'Alice', level: 10 },
+     *   { sessionId: 'abc123' }
+     * );
+     * console.log(`New rank: ${rank}`);
+     * ```
+     */
+    async insertEntry(leaderboardName, sortDir, score, metadata, privateMetadata) {
+        const res = await fetch(`${this.client.apiUrl}/leaderboard-entries`, {
+            method: "POST",
+            headers: this.client.apiHeaders,
+            body: JSON.stringify({
+                leaderboardName,
+                sortDir,
+                score,
+                metadata,
+                privateMetadata,
+                upsert: false,
+            }),
+        });
+        return await res.json();
+    }
+    /**
+     * Add or update the latest entry for the current client in a leaderboard.
+     *
+     * Replaces the previous entry if one exists for this client. Use this when you only want
+     * to keep the latest or best score per player (e.g., daily high score).
+     *
+     * @param leaderboardName The name of the leaderboard to upsert the entry in
+     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
+     *                "desc" for highest-is-best (e.g., points)
+     * @param score The numeric score value
+     * @param metadata Public metadata visible to all players (e.g., player name, completion time)
+     * @param privateMetadata Private metadata only accessible via API calls (e.g., device ID)
+     * @returns A promise resolving to an object with the entry's updated rank
+     *
+     * @example
+     * ```typescript
+     * const { rank } = await kmClient.leaderboard.upsertEntry(
+     *   'daily-scores',
+     *   'desc',
+     *   2000,
+     *   { playerName: 'Bob', completionTime: 120 },
+     *   { deviceId: 'xyz789' }
+     * );
+     * console.log(`Updated rank: ${rank}`);
+     * ```
+     */
+    async upsertEntry(leaderboardName, sortDir, score, metadata, privateMetadata) {
+        const res = await fetch(`${this.client.apiUrl}/leaderboard-entries`, {
+            method: "POST",
+            headers: this.client.apiHeaders,
+            body: JSON.stringify({
+                leaderboardName,
+                sortDir,
+                score,
+                metadata,
+                privateMetadata,
+                upsert: true,
+            }),
+        });
+        return await res.json();
+    }
+    /**
+     * List entries in a leaderboard with pagination.
+     *
+     * Retrieves a sorted list of leaderboard entries. Use skip and limit parameters for
+     * pagination (e.g., showing top 10, or implementing "load more" functionality).
+     *
+     * @param leaderboardName The name of the leaderboard to query
+     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
+     *                "desc" for highest-is-best (e.g., points)
+     * @param skip Number of entries to skip for pagination (default: 0)
+     * @param limit Maximum number of entries to return (default: 100)
+     * @returns A promise resolving to a paginated list of entries with rank, score, and metadata
+     *
+     * @example
+     * ```typescript
+     * // Get top 10 scores
+     * const { items, total } = await kmClient.leaderboard.listEntries(
+     *   'weekly-scores',
+     *   'desc',
+     *   0,
+     *   10
+     * );
+     *
+     * items.forEach(entry => {
+     *   console.log(`Rank ${entry.rank}: ${entry.metadata.playerName} - ${entry.score}`);
+     * });
+     * ```
+     */
+    async listEntries(leaderboardName, sortDir, skip = 0, limit = 100) {
+        const encodedLeaderboardName = encodeURIComponent(leaderboardName);
+        const res = await fetch(`${this.client.apiUrl}/leaderboard-entries?leaderboardName=${encodedLeaderboardName}&sortDir=${sortDir}&skip=${skip}&limit=${limit}`, {
+            headers: this.client.apiHeaders,
+        });
+        return await res.json();
+    }
+    /**
+     * Get the best entry for a specific client in a leaderboard.
+     *
+     * Retrieves the highest-ranked entry for a client based on the sort direction.
+     * Defaults to the current client if no clientId is provided.
+     *
+     * @param leaderboardName The name of the leaderboard to query
+     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
+     *                "desc" for highest-is-best (e.g., points)
+     * @param clientId The client ID to get the best entry for (optional, defaults to current client)
+     * @returns A promise resolving to the best entry with rank, score, and metadata
+     *
+     * @example
+     * ```typescript
+     * // Get current client's best entry
+     * const myBest = await kmClient.leaderboard.getBestEntry('all-time-high', 'desc');
+     * console.log(`My best: Rank ${myBest.rank}, Score ${myBest.score}`);
+     *
+     * // Get another player's best entry
+     * const otherBest = await kmClient.leaderboard.getBestEntry(
+     *   'all-time-high',
+     *   'desc',
+     *   'other-client-id'
+     * );
+     * ```
+     */
+    async getBestEntry(leaderboardName, sortDir, clientId) {
+        const encodedLeaderboardName = encodeURIComponent(leaderboardName);
+        const res = await fetch(`${this.client.apiUrl}/leaderboard-entries/best?leaderboardName=${encodedLeaderboardName}&sortDir=${sortDir}&clientId=${clientId || this.client.id}`, {
+            headers: this.client.apiHeaders,
+        });
+        return await res.json();
+    }
+}

package/dist/services/kokimoki-storage.d.ts

@@ -0,0 +1,155 @@
+import { KokimokiClient } from "../core";
+import type { Paginated, Upload } from "../types";
+/**
+ * Kokimoki Storage Service
+ *
+ * Provides file upload and management capabilities for game applications. Ideal for media files
+ * (images, videos, audio) and other data not suitable for real-time stores (JSON, text files).
+ *
+ * **Key Features:**
+ * - Upload files to cloud storage with CDN delivery
+ * - Tag-based organization and filtering
+ * - Query uploads by client, MIME type, or tags
+ * - Pagination support for large collections
+ * - Public CDN URLs for direct access
+ *
+ * **Common Use Cases:**
+ * - Player avatars and profile images
+ * - Game screenshots and replays
+ * - User-generated content
+ * - Asset uploads (levels, maps, custom skins)
+ * - JSON configuration files
+ *
+ * Access via `kmClient.storage`
+ *
+ * @example
+ * ```typescript
+ * // Upload an image
+ * const upload = await kmClient.storage.upload('avatar.jpg', imageBlob, ['profile']);
+ *
+ * // Query user's uploads
+ * const myUploads = await kmClient.storage.listUploads({
+ *   clientId: kmClient.id
+ * });
+ *
+ * // Use in store
+ * await kmClient.transact([store], (state) => {
+ *   state.playerAvatar = upload.url;
+ * });
+ * ```
+ */
+export declare class KokimokiStorageService {
+    private readonly client;
+    constructor(client: KokimokiClient);
+    private createUpload;
+    private uploadChunks;
+    private completeUpload;
+    /**
+     * Upload a file to cloud storage.
+     *
+     * Uploads a file (Blob) to Kokimoki storage and returns an Upload object with a public CDN URL.
+     * Files are automatically chunked for efficient upload. The returned URL can be used directly
+     * in your application (e.g., in img tags or store state).
+     *
+     * @param name The filename for the upload
+     * @param blob The Blob object containing the file data
+     * @param tags Optional array of tags for organizing and filtering uploads (default: [])
+     * @returns A promise resolving to the Upload object with CDN URL and metadata
+     *
+     * @example
+     * ```typescript
+     * // Upload image with tags
+     * const upload = await kmClient.storage.upload(
+     *   'avatar.jpg',
+     *   imageBlob,
+     *   ['profile', 'avatar']
+     * );
+     *
+     * // Use the CDN URL
+     * console.log(upload.url); // https://cdn.kokimoki.com/...
+     *
+     * // Store in game state
+     * await kmClient.transact([store], (state) => {
+     *   state.players[kmClient.id].avatar = upload.url;
+     * });
+     * ```
+     */
+    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
+    /**
+     * Update metadata for an existing upload.
+     *
+     * Allows you to replace the tags associated with an upload. Useful for reorganizing
+     * or recategorizing uploaded files.
+     *
+     * @param id The upload ID to update
+     * @param update Object containing the new tags array
+     * @returns A promise resolving to the updated Upload object
+     *
+     * @example
+     * ```typescript
+     * // Update tags
+     * const updated = await kmClient.storage.updateUpload(upload.id, {
+     *   tags: ['archived', 'old-profile']
+     * });
+     * ```
+     */
+    updateUpload(id: string, update: {
+        tags?: string[];
+    }): Promise<Upload>;
+    /**
+     * Query uploaded files with filtering and pagination.
+     *
+     * Retrieves a list of uploads matching the specified criteria. Supports filtering by
+     * client (uploader), MIME types, and tags. Use pagination for large collections.
+     *
+     * @param filter Optional filter criteria
+     * @param filter.clientId Filter by uploader's client ID
+     * @param filter.mimeTypes Filter by MIME types (e.g., ['image/jpeg', 'image/png'])
+     * @param filter.tags Filter by tags (all specified tags must match)
+     * @param skip Number of results to skip for pagination (default: 0)
+     * @param limit Maximum number of results to return (default: 100)
+     * @returns A promise resolving to paginated Upload results with total count
+     *
+     * @example
+     * ```typescript
+     * // Get current user's images
+     * const myImages = await kmClient.storage.listUploads({
+     *   clientId: kmClient.id,
+     *   mimeTypes: ['image/jpeg', 'image/png']
+     * });
+     *
+     * // Get all profile avatars
+     * const avatars = await kmClient.storage.listUploads({
+     *   tags: ['profile', 'avatar']
+     * });
+     *
+     * // Pagination
+     * const page2 = await kmClient.storage.listUploads({}, 10, 10);
+     * ```
+     */
+    listUploads(filter?: {
+        clientId?: string;
+        mimeTypes?: string[];
+        tags?: string[];
+    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
+    /**
+     * Permanently delete an uploaded file.
+     *
+     * Removes the file from cloud storage and the CDN. The URL will no longer be accessible.
+     * This operation cannot be undone.
+     *
+     * @param id The upload ID to delete
+     * @returns A promise resolving to deletion confirmation
+     *
+     * @example
+     * ```typescript
+     * // Delete an upload
+     * const result = await kmClient.storage.deleteUpload(upload.id);
+     * console.log(`Deleted: ${result.deletedCount} file(s)`);
+     * ```
+     */
+    deleteUpload(id: string): Promise<{
+        acknowledged: boolean;
+        deletedCount: number;
+    }>;
+}