Open-source Xbox-inspired desktop launcher for Xodus on Linux
TypeScript
import type {RuntimeFamily,GameRuntimeSelection,InstalledRuntimeFamily,RuntimeBuildApproval,RuntimePrefixAnchors,RuntimePrefixIdentity} from './runtime-selection.js';
export type Page = 'home' | 'store' | 'library' | 'downloads' | 'settings' | 'social';
export interface BackendCapabilities {
commands: string[];
account: boolean;
profile?: boolean;
gameActivity?: boolean;
achievements?: boolean;
library?: boolean;
nativeSocial?: boolean;
login: boolean;
externalAuth?: boolean;
logout: boolean;
download: boolean;
streaming: boolean;
streamingProgressJson?: boolean;
/** `run --license-cache` and `offline-pc --license-cache`: device-bound offline
* licenses that the backend validates against their lease on every load and
* removes on every known revocation. Older caches are never handed a path. */
licenseCache?: boolean;
/** `offline-pc`: show or change the account's designated offline PC. */
offlinePc?: boolean;
/** `run --offline`: skip Microsoft entirely and launch on the stored offline license. */
offlineLaunch?: boolean;
/** `login --player` / `logout --player`: a second, separate Xbox player account. */
playerAccount?: boolean;
licenseProfile?: boolean;
savedAccounts?: boolean;
streamingControls?: boolean;
streamingBandwidthLimit?: boolean;
streamingUpdateRecovery?: boolean;
packageSelection?: boolean;
contentPackageSelection?: boolean;
run: boolean;
version?: string;
}
export interface AuthStatus {
running: boolean;
stored: boolean | null;
username?: string;
/** Separate Xbox player account, when the backend stores one next to the license account. */
player?: string;
gamertag?: string;
avatarDataUrl?: string;
licenseAvatarDataUrl?: string;
saved?: string[];
savedAccountsEnabled?: boolean;
subscription?: GamePassSubscription;
lastResult?: 'success' | 'failed';
lastAction?: 'login' | 'logout';
note: string;
}
export interface GamePassSubscription {
status: 'active' | 'none' | 'unknown';
productIds: string[];
checkedAt: string;
}
export interface BackendStatus {
available: boolean;
source: 'external' | 'managed' | 'none';
binaryPath?: string;
commit?: string;
upstreamCommit?: string;
updateAvailable: boolean;
checking: boolean;
updating: boolean;
externalRoot: string;
capabilities: BackendCapabilities;
blockReason?: string;
linuxRunPatch?: string;
recipeSha256?: string;
version?: string;
delivery?: 'release' | 'local';
releaseAvailable?: boolean;
releaseVersion?: string;
phase?: string;
}
export interface ManagedRuntimeOptions {allowCachyos:boolean;allowPrerelease:boolean;}
export interface ManagedFamilyStatus {
id:RuntimeFamily;installed?:InstalledRuntimeFamily;version?:string;channel?:'stable'|'prerelease';
available?:{version:string;candidateSha256:string;sourceCommit:string;archiveName:string;requiresBackendVersion:string;requiresLauncherVersion:string};
checking:boolean;installing:boolean;updateAvailable?:boolean;phase?:string;error?:string;
}
export interface ManagedFamilyInstallResult {
family:RuntimeFamily;success:boolean;committed:boolean;buildId?:string;
durability:'confirmed'|'unknown'|'not-committed';error?:string;
}
export interface RuntimeStatus {
managedFamilies?:ManagedFamilyStatus[];
managedRevision?:number;
variants?: InstalledRuntimeFamily[];
installed: boolean;
checking: boolean;
updating: boolean;
runtimeRoot: string;
name?: string;
winePath?: string;
commit?: string;
upstreamCommit?: string;
artifactName?: string;
artifactExpiresAt?: string;
artifactAvailable: boolean;
// Prebuilt runtime with the Nexus xgameruntime patches, published on the
// Xodus Nexus GitHub releases. Preferred over the official snapshot.
nexusAvailable?: boolean;
nexusName?: string;
nexusVersion?: string;
nexusChecking?: boolean;
nexusError?: string;
prerequisites: { gh: boolean; authenticated: boolean; tar: boolean; sha512sum: boolean };
phase?: string;
error?: string;
}
export interface GameLaunchTools {
dualSenseCompatibility?: boolean;
dualShock4Compatibility?: boolean;
mangoHud: boolean;
gamescope: boolean;
gamescopeArgs: string;
launchOptions: string;
}
export interface Game {
id: string;
title: string;
path: string;
storeId?: string;
offerProductId?: string; // Requested Store edition, not a license or replacement for the base identity.
publisher?: string;
installedVersion?: string;
packageName?: string;
licenseAccount?: string; // Store account the game was installed with.
executable?: string;
winePath?: string; // Legacy saved field; ignored for launch.
runtime?: GameRuntimeSelection;
runtimeSeparatePrefix?: boolean;
runtimeBuild?: RuntimeBuildApproval; // Old prefix origin only, never a launch pin.
runtimePrefixes?: RuntimePrefixAnchors; // Legacy per-family path metadata, never a launch pin.
/** Backend-owned durable prefix location. Captured from the persisted state
* before a selection change; it survives family switches and reloads and is
* never accepted from the renderer. */
runtimePrefixIdentity?: RuntimePrefixIdentity;
launchArgs?: string;
launchTools?: GameLaunchTools;
locale?: string;
coverDataUrl?: string;
coverUrl?: string; // Store box art, preferred over the installation's small logo.
heroUrl?: string; // Wide Store artwork for the game detail panel.
installState: 'ready' | 'incomplete' | 'imported';
installMessage?: string;
updateIncomplete?: boolean; // Refreshed from the backend's on-disk update barrier.
vcRedistEncrypted?: boolean;
antiCheat?: {
provider: 'Easy Anti-Cheat';
executable?: string;
encryptedTarget: boolean;
};
addedAt: string;
/** Completion of a genuine new installation. Older profiles and imports have
* no value, so presentation must not treat `addedAt` as proof of installation. */
installedAt?: string;
}
export interface GameLaunchOptions {
cloudSaves: boolean;
cloudReason?: string;
vcInstall: boolean;
vcReason?: string;
}
export interface DownloadTask {
source?: 'store';
id: string;
kind?: 'install' | 'update' | 'content';
gameId?: string;
title: string;
productId: string;
selectedContentId?: string;
selectionMarket?: string;
destination: string;
status: 'queued' | 'running' | 'paused' | 'complete' | 'failed' | 'cancelled';
canPause?: boolean;
controlPending?: boolean;
cancelling?: boolean;
progress: number | null;
downloadedBytes?: number;
networkBytes?: number;
reusedBytes?: number;
totalBytes?: number;
transferRate?: string;
coverUrl?: string; // Store box art for the queued product, for the queue list.
phase: string;
log: string[];
startedAt: string;
finishedAt?: string;
exitCode?: number;
error?: string;
}
export interface DownloadCancelOptions { deleteFilesAllowed: boolean; reason?: string }
export interface GameOperation {
id: string;
gameId: string;
title: string;
kind?: 'launch' | 'prerequisite';
status: 'preparing' | 'running' | 'stopping' | 'complete' | 'failed';
phase: string;
log: string[];
logPath?: string;
startedAt: string;
finishedAt?: string;
error?: string;
cloudSaveWarning?: string;
}
export interface Settings {
closeToTray?: boolean;
multiAccountEnabled?: boolean;
interfaceLanguage?: string;
installRoot: string;
market: string;
parallelDownloads: number;
downloadLimitMiB?: number;
shaderCacheLimitGiB?: number;
winePath: string;
externalXodusRoot: string;
runtimeRoot: string;
verboseLogs: boolean;
overlayEnabled?:boolean;
overlayShortcut?:string;
overlaySide?:'left'|'right';
firstRunCompleted?: boolean;
}
export type ComponentUpdateOutcome = 'updated' | 'unchanged' | 'skipped' | 'stale' | 'committed-needs-attention' | 'failed-before-commit' | 'not-run' | 'deferred';
export interface ComponentUpdatePlanItem {
id: string;
component: 'backend' | 'runtime' | 'launcher';
label: string;
currentVersion?: string;
targetVersion?: string;
state: 'ready' | 'unchanged' | 'skipped' | 'deferred';
reason?: string;
}
export interface ComponentUpdatePlan { id: string; createdAt: string; items: ComponentUpdatePlanItem[] }
export interface ComponentUpdateItemResult {
id: string;
outcome: ComponentUpdateOutcome;
message?: string;
committed: boolean;
retryable: boolean;
}
export interface ComponentUpdateBatchResult { planId: string; items: ComponentUpdateItemResult[]; restartRequired: boolean }
export interface ComponentUpdatesStatus { running: boolean; phase?: string; plan?: ComponentUpdatePlan; result?: ComponentUpdateBatchResult }
export interface LauncherUpdate {
currentVersion: string;
latestVersion?: string;
releaseUrl?: string;
checking: boolean;
checkedAt?: string;
updating?: boolean;
progress?: number;
phase?: string;
error?: string;
canInstall?: boolean;
restartRequired?: boolean;
canRollback?: boolean;
}
export interface GameUpdate {
checking: boolean;
available?: boolean;
latestVersion?: string;
checkedAt?: string;
error?: string;
}
export interface DiagnosticLog { name: string; content: string; truncated: boolean }
export interface DiagnosticReport { name: string; content: string }
export interface KeyringStatus {
canCreate?: boolean;
canUnlock?: boolean;
state: 'ready' | 'locked' | 'stopped' | 'disabled' | 'missing' | 'needs-setup' | 'unavailable';
gameMode: boolean;
canStart: boolean;
message: string;
}
export interface SteamKeyboardRequest { x: number; y: number; width: number; height: number; mode: 0 | 1 | 2 | 3 }
export interface LauncherApi {
onLauncherPage(callback:(page: "home"|"library"|"store"|"settings")=>void):()=>void;
showTouchKeyboard(field?: SteamKeyboardRequest): Promise<boolean>;setXboxOverlayRecording(recording:boolean):Promise<void>;}
/** The Xbox app's "Offline permissions" setting for this device, as Microsoft reports it. */
export interface OfflinePermissions {
/** Local launcher check, not a licensing grant or a Microsoft response field. */
launchSupported?: boolean;
enabled: boolean;
/** For a change: whether Microsoft applied it. */
requestSuccess: boolean;
remainingToggles?: number;
maxToggles?: number;
periodDays?: number;
/** When the next change becomes possible once none remain. */
nextChangeAt?: string;
checkedAt: string;
}
/** Reachability of Microsoft's sign-in hosts, probed by the launcher. */
export interface ConnectivityStatus {
state: 'online' | 'offline' | 'unknown';
checkedAt?: string;
/** Why the launcher considers Microsoft unreachable. */
reason?: string;
}
export interface AppSnapshot {
overlayShortcut?:{state:'disabled'|'recording'|'requested'|'registered'|'unavailable';message?:string;backend?:string};
social?: import('./game-invites.js').GameInviteState;
backend: BackendStatus;
runtime: RuntimeStatus;
connectivity?: ConnectivityStatus;
games: Game[];
downloads: DownloadTask[];
settings: Settings;
auth: AuthStatus;
launcherUpdate?: LauncherUpdate;
componentUpdates?: ComponentUpdatesStatus;
gameOperation?: GameOperation;
gameUpdates?: Record<string, GameUpdate>;
downloadProgressSupported?: boolean;
}
export interface InstallRequest {
source?: 'store';
productId: string;
title: string;
destination: string;
selectedContentId?: string;
selectionMarket?: string;
}
export interface InstallChoice {
productId: string;
contentId: string;
title: string;
platform: string;
packageFormat: string;
kind: string;
supported: boolean;
parentProductId?: string;
mainPackageFamilyName?: string;
downloadBytes?: number;
installBytes?: number;
}
export interface InstallPlan {
schema: 1;
rootProductId: string;
market: string;
status: 'ready' | 'choice' | 'unavailable';
choices: InstallChoice[];
availableBytes?: number;
}
export interface GameContentItem {
productId: string;
title: string;
access?: LibraryAccess;
status: 'installed' | 'available' | 'verify' | 'unlicensed' | 'unsupported' | 'bundle' | 'license-only';
downloadBytes?: number;
note: string;
}
export interface GameContentPlan {
gameId: string;
checkedAt: string;
runtimeSupported?: boolean;
items: GameContentItem[];
}
export interface CatalogProduct {
productId: string;
installProductId?: string;
title: string;
description: string;
publisher?: string;
posterUrl?: string;
heroUrl?: string;
storeUrl?: string;
categories: string[];
purchasePrice?: string;
includedWith?: string;
releaseDate?: string;
averageRating?: number;
installability: 'supported' | 'unsupported' | 'unknown';
packageFormat?: string;
supportNote: string;
}
/** Public Store browsing is the only non-account catalog presentation scope.
* It selects read-only metadata from the neutral public Store market only; it
* never proves ownership or grants install access, and account activity,
* achievements and licensing keep their configured market. */
export type GameDetailsScope = 'public-store';
/** A saved installation ID, or an explicit read-only Store catalog identity.
* An unscoped identity keeps the configured/effective account market; only an
* explicit `public-store` scope selects public browsing metadata. */
export type GameDetailsTarget = string | {productId:string; scope?:GameDetailsScope};
/** Public catalog data only, never an ownership/installation decision. */
export interface GameStoreDetails {
productId: string;
title: string;
description: string;
publisher?: string;
heroUrl?: string;
categories: string[];
screenshots: string[];
xboxTitleId?: string;
releaseDate?: string;
}
export interface GameActivity {
status: 'available' | 'unavailable' | 'unsupported' | 'signed-out' | 'error';
minutesPlayed?: number;
lastPlayed?: string;
partial?: boolean;
}
export interface GameAchievement {
id: string;
name: string;
description: string;
state: 'unlocked' | 'in-progress' | 'locked';
secret: boolean;
revoked: boolean;
gamerscore?: number;
iconUrl?: string;
unlockedAt?: string;
progress?: number;
}
export interface GameAchievements {
status: 'available' | 'unavailable' | 'unsupported' | 'signed-out' | 'error';
items?: GameAchievement[];
partial?: boolean;
}
export interface CatalogSearchResult {
query: string;
market: string;
products: CatalogProduct[];
cursor?: string;
hasMore: boolean;
fetchedAt: string;
source: 'Microsoft Store';
}
/** Public presence in the official PC Game Pass recent collection.
* This is not an owned Library page and grants no account access. */
export interface RecentGamePassShelf {
market: string;
products: CatalogProduct[];
fetchedAt: string;
source: 'Microsoft Game Pass catalog';
stale?: boolean;
}
export type LibraryAccess = 'owned' | 'gamepass' | 'other';
export interface StoreAccess {
configuredMarket: string;
account: string;
backend: string;
market: string;
checkedAt: string;
expiresAt: string;
accessByProductId: Record<string, LibraryAccess>;
}
export interface AccountLibraryPage {
kind: 'all' | LibraryAccess;
sort?: 'recent-gamepass';
recentProductIds?: string[];
products: (CatalogProduct & { access: LibraryAccess })[];
accessByProductId: Record<string, LibraryAccess>;
unclassifiedEntitlements?: number;
excludedEntitlements?: number;
cursor?: string;
checkedAt: string;
skippedEntitlements?: number;
}
export interface XboxFriend {
xuid: string;
avatarUrl?:string|null;
gamertag: string;
online: boolean;
presence: string;
favorite: boolean;
inParty: boolean;
}
export interface XboxMessage { id: string; sender: string; timestamp: string | null; text: string; hidden: boolean; mine: boolean }
export interface XboxPlayerProfile { xuid:string;gamertag:string;gamerscore:string|null;avatarUrl?:string|null }
export type XboxPeopleList = 'search'|'recent'|'suggested'|'blocked'|'received-requests'|'sent-requests';
export type XboxRelationshipAction = 'send-request'|'accept-request'|'cancel-request'|'decline-request'|'remove-friend'|'favorite'|'unfavorite'|'block'|'unblock';
export interface XboxRelationship {
xuid:string;isFriend:boolean;isFollowing:boolean;isFollower:boolean;favorite:boolean;blocked:boolean;
requestState:'none'|'incoming'|'outgoing'|'unknown';
}
export interface XboxPerson extends XboxFriend {reason?:string;lastSeen?:string}
export interface XboxPeoplePage {items:XboxPerson[];continuation?:string|null;truncated?:boolean}
export interface XboxPlayerDetails extends XboxPlayerProfile {
isSelf?:boolean;
bio?:string;location?:string;tenure?:string;
colors?:{primary?:string;secondary?:string;tertiary?:string};
counts?:{friends?:number;followers?:number;following?:number};
relationship?:XboxRelationship;
}
export interface XboxProfileGame {
titleId:string;name:string;imageUrl?:string;lastPlayed?:string;
currentGamerscore?:number;totalGamerscore?:number;achievementsUnlocked?:number;achievementsTotal?:number;
}
export interface XboxProfileGames {items:XboxProfileGame[];continuation?:string|null;truncated?:boolean}
export interface XboxProfileRequest { id:string;xuid:string }
export interface XboxConversation {
id: string;
avatarUrl?:string|null;
type: string | null;
participants: string[];
gamertag: string;
unread: boolean;
lastMessage: XboxMessage | null;
}
export interface XboxPartyState {
phase: 'idle' | 'connecting' | 'connected' | 'leaving' | 'error';
id?: string;
selfXuid?: string;
members: {xuid:string;role:string|null}[];
error?: string;
}
export interface XboxPartyAnswer { id:string;answer:{sdpType:'answer';sdp:string;iceCandidates:RTCIceCandidateInit[]} }
export interface XboxInvite {
id:string;kind:'party'|'game';gamertag:string;sender:string;
expiresAt:number;sentAt:number|null;titleId:string|null;titleName:string|null;
}
export interface XboxVoiceApi {
getXboxParty(): Promise<XboxPartyState>;
startXboxParty(offer:string,partyId?:string): Promise<XboxPartyAnswer>;
getXboxActiveParties(): Promise<string[]>;
leaveExistingXboxParty(id:string): Promise<void>;
confirmXboxParty(id:string): Promise<void>;
leaveXboxParty(): Promise<void>;
inviteXboxPartyFriend(xuid:string): Promise<void>;
xboxVoiceAllowed(xuid:string): Promise<boolean>;
allowXboxMicrophone(): Promise<void>;
onXboxPartyState(callback:(state:XboxPartyState)=>void):()=>void;
getXboxInvites():Promise<XboxInvite[]>;
acceptXboxPartyInvite(offer:string,id:string):Promise<XboxPartyAnswer>;
onXboxInvitesChanged(callback:(invites:XboxInvite[])=>void):()=>void;
}
export interface XboxVoiceState {
connected:boolean;muted:boolean;audioBlocked:boolean;mutedMembers:string[];error?:string;
}
export type XboxVoiceCommand =
| {type:'start';partyId?:string}
| {type:'accept';inviteId:string}
| {type:'mute';xuid:string;muted:boolean}
| {type:'setMuted';muted:boolean}
| {type:'leave'}
| {type:'resume'};
export interface XboxVoiceControlApi {
getXboxVoiceState():Promise<XboxVoiceState>;
onXboxVoiceState(callback:(state:XboxVoiceState)=>void):()=>void;
controlXboxVoice(command:XboxVoiceCommand):Promise<void>;
}
export interface XboxVoiceHostApi {
xboxVoiceHostReady():Promise<void>;
publishXboxVoiceHostState(state:XboxVoiceState):Promise<void>;
onXboxVoiceHostCommand(callback:(request:{id:string;command:XboxVoiceCommand})=>void):()=>void;
completeXboxVoiceHostCommand(id:string,error?:string):Promise<void>;
}
export type XboxPartyControlApi = Pick<XboxVoiceApi,
'getXboxParty'|'getXboxActiveParties'|'leaveExistingXboxParty'|'inviteXboxPartyFriend'|
'onXboxPartyState'|'getXboxInvites'|'onXboxInvitesChanged'> & XboxVoiceControlApi;
export interface LauncherApi extends XboxVoiceApi,XboxVoiceControlApi,XboxVoiceHostApi {}
export interface XboxSocialApi {
openXboxPlayerProfile(xuid:string):Promise<void>;
popOutXboxChat?(xuid:string):Promise<void>;
getXboxProfileRequest?():Promise<XboxProfileRequest|undefined>;
onXboxProfileRequest?(callback:(request:XboxProfileRequest|undefined)=>void):()=>void;
completeXboxProfileRequest?(id:string,hide?:boolean):Promise<void>;
getXboxGameInviteAvailability():Promise<XboxGameInviteAvailability>;
sendXboxGameInvite(xuid:string):Promise<void>;
getXboxPlayerDetails(xuid:string):Promise<XboxPlayerDetails>;
getXboxPlayerGames(xuid:string):Promise<XboxProfileGames>;
getXboxPeople(list:XboxPeopleList,query?:string):Promise<XboxPeoplePage>;
getXboxRelationship(xuid:string):Promise<XboxRelationship>;
changeXboxRelationship(account:string,xuid:string,action:XboxRelationshipAction):Promise<void>;
getXboxPlayerProfile(xuid:string):Promise<XboxPlayerProfile>;
getXboxFriends():Promise<XboxFriend[]>;
getXboxInbox():Promise<XboxConversation[]>;
getXboxConversation(xuid:string):Promise<XboxMessage[]>;
sendXboxMessage(account:string,xuid:string,text:string):Promise<XboxMessageReceipt>;
}
export interface XboxMessageReceipt {id:string}
export interface XboxGameInviteAvailability {canInvite:boolean;gameId?:string;title?:string;reason?:string}
export interface XboxChatReadState {account:string;binary:string;keys:string[]}
export interface LauncherApi {
showTouchKeyboard(field?: SteamKeyboardRequest): Promise<boolean>;
closeXboxChat():Promise<void>;
getXboxChatReads():Promise<XboxChatReadState|undefined>;
onXboxChatReads(callback:(state:XboxChatReadState)=>void):()=>void;
viewedXboxChat(account:string,binary:string,peer:string,ids:string[]):Promise<void>;
getXboxDesktopProfile():Promise<XboxProfileRequest|undefined>;
onXboxDesktopProfile(callback:(request:XboxProfileRequest|undefined)=>void):()=>void;
nativeSocial:XboxSocialApi;
inviteXboxFriend(gameId:string,xuid:string):Promise<void>;
chooseGameInviteRecipient(id: string, xuid: string): Promise<void>;
cancelGameInvite(id: string): Promise<void>;
acceptGameInvite(id: string): Promise<void>;
onOpenFriends(callback: () => void): () => void;
getXboxFriends(): Promise<import('./social.js').XboxFriend[]>;
getXboxConversation(xuid: string): Promise<import('./social.js').XboxConversation>;
sendXboxMessage(xuid: string, text: string): Promise<import('./social.js').XboxMessageReceipt>;
closeXboxSocial(): Promise<void>;
getSnapshot(): Promise<AppSnapshot>;
refreshBackend(): Promise<BackendStatus>;
checkBackendUpdate(): Promise<BackendStatus>;
updateBackend(): Promise<void>;
refreshRuntime(): Promise<RuntimeStatus>;
getRuntimeFamilies(): Promise<InstalledRuntimeFamily[]>;
checkRuntimeUpdate(): Promise<RuntimeStatus>;
checkManagedRuntime(family:RuntimeFamily,options:ManagedRuntimeOptions):Promise<ManagedFamilyStatus>;
installManagedRuntime(family:RuntimeFamily,expectedCandidateSha256:string,options:ManagedRuntimeOptions):Promise<ManagedFamilyInstallResult>;
checkNexusRuntime(): Promise<RuntimeStatus>;
installRuntime(): Promise<void>;
installNexusRuntime(): Promise<void>;
rollbackRuntimePreview(): Promise<void>;
refreshAccount(): Promise<AuthStatus>;
checkKeyring(): Promise<KeyringStatus>;
startKeyring(): Promise<KeyringStatus>;
createKeyringCollection(): Promise<KeyringStatus>;
onKeyringStatus(callback: (status: KeyringStatus) => void): () => void;
planComponentUpdates(): Promise<ComponentUpdatePlan>;
applyComponentUpdates(planId: string): Promise<ComponentUpdateBatchResult>;
getComponentUpdatesStatus(): Promise<ComponentUpdatesStatus>;
retryComponentUpdate(planId: string, itemId: string): Promise<ComponentUpdateBatchResult>;
checkLauncherUpdate(): Promise<LauncherUpdate | undefined>;
installLauncherUpdate(): Promise<void>;
restartLauncher(): Promise<void>;
rollbackLauncherUpdate(): Promise<void>;
checkGameUpdates(id?: string): Promise<void>;
stopGameUpdateCheck(): Promise<void>;
readDiagnosticLog(operationId: string): Promise<DiagnosticLog>;
copyDiagnosticLog(operationId: string): Promise<void>;
revealDiagnosticLog(operationId: string): Promise<void>;
readBackendDiagnosticLog(): Promise<DiagnosticLog>;
createDiagnosticReport(gameId?: string): Promise<DiagnosticReport>;
saveDiagnosticReport(content: string): Promise<boolean>;
login(player?: boolean): Promise<void>;
logout(player?: boolean): Promise<void>;
useAccount(name: string): Promise<void>;
forgetAccount(name: string): Promise<void>;
offlinePermissions(): Promise<OfflinePermissions>;
setOfflinePermissions(enabled: boolean): Promise<OfflinePermissions>;
searchCatalog(query: string, cursor?: string): Promise<CatalogSearchResult>;
getFeaturedCatalog(): Promise<CatalogSearchResult>;
browseCatalog(cursor?: string): Promise<CatalogSearchResult>;
getRecentGamePassShelf(): Promise<RecentGamePassShelf>;
getStoreAccess(): Promise<StoreAccess>;
getAccountLibrary(kind: AccountLibraryPage['kind'], cursor?: string, refresh?: boolean, sort?: AccountLibraryPage['sort']): Promise<AccountLibraryPage>;
startInstall(request: InstallRequest): Promise<string>;
getInstallPlan(productId: string, destination?: string): Promise<InstallPlan>;
getGameContent(id: string): Promise<GameContentPlan>;
installGameContent(id: string, productId: string): Promise<string>;
updateInstalledGame(id: string): Promise<string>;
getDownloadCancelOptions(id: string): Promise<DownloadCancelOptions>;
cancelDownload(id: string, mode?: 'keep' | 'delete-files'): Promise<void>;
pauseDownload(id: string): Promise<void>;
resumeDownload(id: string): Promise<void>;
removeDownload(id: string): Promise<void>;
clearFinishedDownloads(): Promise<void>;
importGame(path?: string): Promise<Game | null>;
updateGame(id: string, patch: Partial<Pick<Game, 'title' | 'executable' | 'launchArgs' | 'locale' | 'launchTools' | 'runtime' | 'runtimeSeparatePrefix'>>): Promise<Game>;
getGameLocales(id: string): Promise<string[]>;
removeGame(id: string, mode: 'library' | 'delete-files'): Promise<void>;
getGameRuntimeReadiness(id: string): Promise<boolean>;
getGameLaunchOptions(id: string): Promise<GameLaunchOptions>;
getGameDetails(id: GameDetailsTarget): Promise<GameStoreDetails | undefined>;
getGameActivity(id: GameDetailsTarget, refresh?: boolean): Promise<GameActivity>;
getGameAchievements(id: GameDetailsTarget, refresh?: boolean): Promise<GameAchievements>;
launchGame(id: string): Promise<void>;
createGameShortcut(id: string, destination: 'desktop' | 'applications'): Promise<string>;
addToSteam(id?: string): Promise<string>;
installGameVcRuntime(id: string): Promise<void>;
cancelGame(): Promise<void>;
updateSettings(patch: Partial<Settings>): Promise<Settings>;
chooseDirectory(defaultPath?: string): Promise<string | null>;
chooseFile(defaultPath?: string): Promise<string | null>;
openPath(path: string): Promise<void>;
onSnapshot(callback: (snapshot: AppSnapshot) => void): () => void;
onOperationLog(callback: (entry: { scope: string; line: string }) => void): () => void;
isDemoTour(): boolean;
}