### Subscribe to Backend Events using Tauri

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Demonstrates how to register event listeners for server logs, installation progress, and status updates. The implementation uses the Tauri API to handle asynchronous event payloads and includes a cleanup mechanism for memory management.

```typescript
import { listen } from '@tauri-apps/api/event';

// Listen for server log events
const unlisten = await listen('server-log', (event) => {
  const { server_id, line, is_stderr } = event.payload;
  console.log(`[Server ${server_id}] ${line}`);
});

// Listen for installation progress
await listen('install-progress', (event) => {
  const { message, progress } = event.payload;
  console.log(`Install: ${message} (${progress}%)`);
});

// Listen for server status changes
await listen('server-status-changed', (event) => {
  const { serverId, status } = event.payload;
  console.log(`Server ${serverId} is now ${status}`);
});

// Cleanup listener when done
unlisten();
```

--------------------------------

### ASA API Plugin Management

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Enables the installation, toggling, and uninstallation of ASA API plugins. Supports importing plugins from local archives and verifying installation status.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Get installed plugins
const plugins = await invoke('get_installed_plugins', { serverId: 1 });

// Toggle plugin enabled/disabled
await invoke('toggle_plugin', { serverId: 1, pluginId: 'plugin1', enabled: true });

// Uninstall plugin
await invoke('uninstall_plugin', { serverId: 1, pluginId: 'plugin1' });
```

--------------------------------

### Manage ARK: Survival Ascended Server Lifecycle via Tauri IPC

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Provides functions to install, start, stop, restart, update, and delete ARK:SA servers. These commands interface with the Rust backend to handle SteamCMD processes, database persistence, and file system operations.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Install a new server
const server = await invoke('install_server', {
  installPath: 'D:/ARK_Servers/Server1',
  name: 'My ARK Server',
  mapName: 'TheIsland_WP',
  gamePort: 7777,
  queryPort: 27015,
  rconPort: 27020
});

// Get all servers
const servers = await invoke('get_all_servers');

// Start a server (with optional update check)
await invoke('start_server', { serverId: 1, updateOnStart: false });

// Start server without mods (for troubleshooting)
await invoke('start_server_no_mods', { serverId: 1 });

// Stop a server
await invoke('stop_server', { serverId: 1 });

// Restart a server
await invoke('restart_server', { serverId: 1 });

// Update server via SteamCMD
await invoke('update_server', { serverId: 1 });

// Delete a server from database
await invoke('delete_server', { serverId: 1 });

// Clone an existing server (copies configs, offsets ports by 10)
const clonedServer = await invoke('clone_server', { sourceServerId: 1 });

// Import existing server installation
const importedServer = await invoke('import_server', {
  installPath: 'D:/Existing_ARK_Server',
  name: 'Imported Server'
});

// Get server logs
const logs = await invoke('get_server_logs', {
  serverId: 1,
  installPath: 'D:/ARK_Servers/Server1'
});
```

--------------------------------

### Manage CurseForge Mods with TypeScript

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Facilitates mod discovery, installation, and configuration for ARK servers. It handles synchronization with GameUserSettings.ini and provides utilities for mod load order and cache management.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Search CurseForge for mods
const mods = await invoke('search_mods', {
  query: 'structures',
  serverType: 'ASA',
  sortField: 2,
  sortOrder: 'desc'
});

// Install a mod
await invoke('install_mod', {
  serverId: 1,
  modInfo: {
    id: '123456',
    name: 'S+ Structures',
    version: '1.0.0',
    author: 'ModAuthor'
  }
});

// Update mod load order
await invoke('update_mod_order', {
  serverId: 1,
  modIds: ['123456', '789012', '345678']
});

// Apply mods to server (writes INI)
await invoke('apply_mods_to_server', { serverId: 1 });
```

--------------------------------

### Manage Server Clusters with TypeScript API

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

This API facilitates the management of server clusters, enabling character and dino transfers between maps. It allows for creating, modifying, starting, stopping, and deleting clusters, as well as managing server membership. Dependencies include '@tauri-apps/api/core'.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Create a cluster
const cluster = await invoke('create_cluster', {
  name: 'My Cluster',
  serverIds: [1, 2, 3],
  clusterPath: 'D:/ASA_Clusters/MyCluster'  // Optional, auto-generated if null
});
// Returns: { id: 1, name: 'My Cluster', clusterPath: '...', serverIds: [1,2,3] }

// Get all clusters
const clusters = await invoke('get_clusters');

// Get cluster status
const status = await invoke('get_cluster_status', { clusterId: 1 });
// Returns: { clusterId: 1, clusterName: '...', totalServers: 3, runningServers: 2, serverStatuses: [...] }

// Add server to cluster
await invoke('add_server_to_cluster', { clusterId: 1, serverId: 4 });

// Remove server from cluster
await invoke('remove_server_from_cluster', { clusterId: 1, serverId: 4 });

// Update cluster settings
await invoke('update_cluster', {
  clusterId: 1,
  name: 'Renamed Cluster',
  newPath: 'D:/NewClusterPath',
  moveData: true  // Move existing cluster data to new path
});

// Start all servers in cluster (with 5-second delay between each)
await invoke('start_cluster', { clusterId: 1 });

// Stop all servers in cluster
await invoke('stop_cluster', { clusterId: 1 });

// Validate cluster configuration (port conflicts, path issues)
const validation = await invoke('validate_cluster_configuration', { clusterId: 1 });
// Returns: { clusterId: 1, issues: [{ serverId: 2, level: 'error', message: 'Port conflict...' }] }

// Toggle cross-server chat (experimental)
await invoke('toggle_cluster_cross_chat', { clusterId: 1, enabled: true });
const chatEnabled = await invoke('get_cluster_cross_chat_status', { clusterId: 1 });

// Delete cluster
await invoke('delete_cluster', { clusterId: 1 });
```

--------------------------------

### Manage Server Configuration Files

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Provides methods to read and write GameUserSettings.ini and Game.ini files. Requires a server ID and the specific configuration type to perform operations.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Read configuration file
const content = await invoke('read_config', {
  serverId: 1,
  configType: 'GameUserSettings'  // 'GameUserSettings' | 'Game'
});

// Save configuration file
await invoke('save_config', {
  serverId: 1,
  configType: 'GameUserSettings',
  content: '[ServerSettings]\nMaxPlayers=100\nServerPassword=newpass\n...'
});
```

--------------------------------

### Manage Server Backups with TypeScript API

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

This API allows for creating, restoring, verifying, and deleting server backups. It supports various backup types and options for including different server data. Dependencies include '@tauri-apps/api/core'.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Create a backup
const backup = await invoke('create_backup', {
  serverId: 1,
  backupType: 'manual',  // 'auto' | 'manual' | 'pre-update' | 'pre-restart'
  options: {
    includeConfigs: true,
    includeMods: true,
    includeSaves: true,
    includeCluster: false
  }
});
// Returns: { id: 1, serverId: 1, filePath: 'C:/ASA_Backups/...', size: 1024000, ... }

// Get all backups for a server
const backups = await invoke('get_backups', { serverId: 1 });

// Restore a backup
await invoke('restore_backup', {
  backupId: 1,
  options: {
    restoreConfigs: true,
    restoreSaves: true,
    restoreMods: false
  }
});

// Verify backup integrity
const isValid = await invoke('verify_backup', { backupId: 1 });

// Get backup contents (file list)
const contents = await invoke('get_backup_contents', { backupId: 1 });
// Returns: ['ShooterGame/Saved/Config/...', 'ShooterGame/Saved/SavedArks/...', ...]

// Delete a backup
await invoke('delete_backup', { backupId: 1 });

// Cleanup old backups (keep N most recent)
const deleted = await invoke('cleanup_old_backups', {
  serverId: 1,
  keepCount: 5
});
```

--------------------------------

### System and Discord Integration Management

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Handles system resource monitoring, application settings, and Discord bridge configuration. Includes utilities for file dialogs and managing the lifecycle of the Discord bot connection.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Get system information
const sysInfo = await invoke('get_system_info');

// Discord Bridge configuration
await invoke('save_discord_bridge_config', {
  config: {
    cluster_id: 1,
    enabled: true,
    bot_token: 'your-bot-token',
    guild_id: '123456789',
    channel_id: '987654321',
    admin_channel_id: '111222333',
    game_to_discord: true,
    discord_to_game: true,
    server_list_enabled: true,
    server_list_channel_id: '444555666',
    player_list_enabled: true,
    player_list_channel_id: '777888999',
    show_tribe_names: true,
    show_playtime: true
  }
});

// Start/stop Discord bridge
await invoke('start_discord_bridge');
await invoke('stop_discord_bridge');
```

--------------------------------

### Configure ARK: Survival Ascended Server Settings and Automation

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Enables updating server configuration parameters, toggling automation features, and performing data transfers between server instances. These commands ensure changes are synchronized between the SQLite database and local INI files.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Update server settings
await invoke('update_server_settings', {
  serverId: 1,
  maxPlayers: 70,
  serverPassword: 'secretpass',
  adminPassword: 'adminpass123',
  mapName: 'ScorchedEarth_WP',
  sessionName: 'My Public Server',
  gamePort: 7777,
  queryPort: 27015,
  rconPort: 27020,
  ipAddress: '192.168.1.100',
  customArgs: '-NoBattlEye -crossplay'
});

// Toggle automation features
await invoke('toggle_automation', {
  serverId: 1,
  toggleType: 'auto_start',  // 'auto_start' | 'auto_stop' | 'intelligent_mode'
  enabled: true
});

// Transfer settings between servers (copies INI files)
await invoke('transfer_settings', {
  sourceServerId: 1,
  targetServerId: 2
});

// Extract save data (world/player data)
await invoke('extract_save_data', {
  sourceServerId: 1,
  targetServerId: 2
});

// Check server reachability (Public/LAN detection)
const status = await invoke('check_server_reachability', {
  port: 7777,
  protocol: 'UDP'  // 'UDP' for game/query ports, 'TCP' for RCON
});
```

--------------------------------

### Schedule Server Tasks with TypeScript API

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

This API enables scheduling of automated tasks such as restarts, updates, backups, and dino wipes. It supports cron expressions for timing and RCON broadcasts for pre-warning messages. Dependencies include '@tauri-apps/api/core'.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Get scheduler settings
const settings = await invoke('get_scheduler_settings', { serverId: 1 });
// Returns: { serverId: 1, mode: 'basic', basicIntervalHours: 6, ... }

// Save scheduler settings
await invoke('save_scheduler_settings', {
  settings: {
    serverId: 1,
    mode: 'advanced',  // 'disabled' | 'basic' | 'advanced'
    basicIntervalHours: 6,
    basicWarningMinutes: '30,10,5,1',
    advancedTime: '06:00',
    advancedDays: '1,3,5',  // Mon, Wed, Fri
    advancedWarningMinutes: '30,15,10,5,1',
    advancedShutdown: false,
    advancedUpdate: true,
    advancedRestart: true,
    advancedDinoWipe: false
  }
});

// Get scheduled tasks
const tasks = await invoke('get_scheduled_tasks', { serverId: 1 });

// Create a scheduled task
const task = await invoke('create_scheduled_task', {
  request: {
    serverId: 1,
    taskName: 'Daily Restart',
    taskType: 'restart',  // 'restart' | 'update' | 'backup' | 'dino_wipe' | 'broadcast' | 'command'
    cronExpression: '0 6 * * *',  // Every day at 6:00 AM
    command: null,  // For 'command' type
    message: 'Server restarting for daily maintenance',  // For 'broadcast' type
    preWarningMinutes: 30
  }
});

// Toggle task enabled/disabled
await invoke('toggle_scheduled_task', { taskId: 1, enabled: true });

// Delete a scheduled task
await invoke('delete_scheduled_task', { taskId: 1 });
```

--------------------------------

### Server Defaults Configuration (JSON)

Source: https://github.com/sanjay-m6/ark-asa-server-manager-2.0/blob/main/README.md

Defines the default network ports and maximum player count for ARK: Survival Ascended servers managed by the application. These settings can be overridden by specific server configurations.

```json
{
  "gamePort": 7777,
  "queryPort": 27015,
  "rconPort": 27020,
  "maxPlayers": 70
}
```

--------------------------------

### Manage Server RCON Operations with TypeScript

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Provides methods to establish persistent RCON connections, execute administrative commands, manage players, and control server state. These functions interface with the backend via Tauri's invoke system.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Connect to server's RCON
const response = await invoke('rcon_connect', {
  serverId: 1,
  address: '127.0.0.1',
  port: 27020,
  password: 'adminpass123'
});

// Send raw RCON command
const result = await invoke('rcon_send_command', {
  serverId: 1,
  command: 'ListPlayers'
});

// Kick a player
await invoke('rcon_kick_player', {
  serverId: 1,
  steamId: '76561198000000000',
  reason: 'Violation of rules'
});

// Disconnect RCON
await invoke('rcon_disconnect', { serverId: 1 });
```

--------------------------------

### Player Management and Statistics

Source: https://context7.com/sanjay-m6/ark-asa-server-manager-2.0/llms.txt

Facilitates tracking of player statistics, session history, and administrative actions such as whitelisting, banning, and note-taking.

```typescript
import { invoke } from '@tauri-apps/api/core';

// Get all tracked players
const players = await invoke('get_all_players', { limit: 100, offset: 0 });

// Whitelist/Ban management
await invoke('set_player_whitelist', { steamId: '76561198000000000', whitelisted: true });
await invoke('set_player_ban', { steamId: '76561198000000000', banned: true });
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.