decky-frontend-lib/src/globals/steam-client/User.ts

import { EResult, OperationResponse, Unregisterable } from "./shared";

export interface User {
    AuthorizeMicrotxn(txnId: number | string): void;

    CancelLogin(): void;

    CancelMicrotxn(txnId: number | string): void;

    /**
     * Tries to cancel Steam shutdown.
     * @remarks Used in the "Shutting down" dialog.
     */
    CancelShutdown(): void;

    /**
     * Opens the "Change Account" dialog.
     */
    ChangeUser(): void;

    Connect(): Promise<OperationResponse>;

    FlipToLogin(): void;

    /**
     * Forces a shutdown while shutting down.
     * @remarks Used in the "Shutting down" dialog.
     */
    ForceShutdown(): void;

    /**
     * Forgets an account's password.
     * @param accountName Login of the account to forget.
     * @returns a boolean indicating whether the operation succeeded or not.
     */
    ForgetPassword(accountName: string): Promise<boolean>;

    /**
     * Gets your country code.
     * @returns a string containing your country code.
     */
    GetIPCountry(): Promise<string>;

    /**
     * @todo param0 mirrors param3 of {@link RegisterForLoginStateChange}
     */
    GetLoginProgress(callback: (param0: number, param1: number) => void): Unregisterable;

    GetLoginUsers(): Promise<LoginUser[]>;

    GoOffline(): void;

    GoOnline(): void;

    OptOutOfSurvey(): void;

    PrepareForSystemSuspend(): Promise<{
        result: EResult;
    }>;

    Reconnect(): void;

    RegisterForConnectionAttemptsThrottled(callback: (data: ConnectionAttempt) => void): Unregisterable;

    RegisterForCurrentUserChanges(callback: (user: CurrentUser) => void): void;

    RegisterForLoginStateChange(
        callback: (
            /**
             * Empty if not logged in.
             */
            accountName: string,
            state: ELoginState,
            result: EResult,
            param3: number,
            percentage: number,
            /**
             * @todo name is from CLoginStore, but it's always empty, unused ?
             */
            emailDomain: string,
        ) => void
    ): Unregisterable;

    RegisterForPrepareForSystemSuspendProgress(callback: (progress: SuspendProgress) => void): Unregisterable;

    RegisterForResumeSuspendedGamesProgress(callback: (progress: SuspendProgress) => void): Unregisterable;

    RegisterForShowHardwareSurvey(callback: () => void): Unregisterable;

    /**
     * Register a function to be executed when shutdown completes.
     * @param callback The function to be executed on completion.
     */
    RegisterForShutdownDone(callback: (state: EShutdownStep, appid: number, param2: boolean) => void): Unregisterable;

    RegisterForShutdownFailed(callback: (state: EShutdownStep, appid: number, success: boolean) => void): Unregisterable;

    /**
     * Register a function to be executed when Steam starts shutting down.
     * @param callback The function to be executed on shutdown start.
     */
    RegisterForShutdownStart(callback: (param0: boolean) => void): Unregisterable;

    /**
     * Register a function to be executed when shutdown state changes.
     * @param callback The function to be executed on change.
     */
    RegisterForShutdownState(callback: (state: EShutdownStep, appid: number, allowForceQuit: boolean) => void): Unregisterable;

    /**
     * Removes an account from remembered users.
     * @param accountName The account to remove.
     */
    RemoveUser(accountName: string): void;

    RequestSupportSystemReport(reportId: string): Promise<{
        bSuccess: boolean;
    }>;

    ResumeSuspendedGames(param0: boolean): Promise<ResumeSuspendedGamesResult>;

    // Hardware survey information
    RunSurvey(callback: (surveySections: SurveySection[]) => void): void;

    SendSurvey(): void;

    SetAsyncNotificationEnabled(appId: number, enable: boolean): void;

    /**
     * Sets given login credentials, but don't log in to that account.
     * @param accountName Account name.
     * @param password Account password.
     * @param rememberMe Whether to remember that account.
     */
    SetLoginCredentials(accountName: string, password: string, rememberMe: boolean): void;

    SetOOBEComplete(): void;

    ShouldShowUserChooser(): Promise<boolean>;

    /**
     * Signs out and restarts Steam.
     */
    SignOutAndRestart(): void;

    /**
     * Relogin after disabling offline mode. Not sure what else it's useful for,
     * there isn't even a single mention of it in steam's js, lol
     */
    StartLogin(): void;

    /**
     * Toggles offline mode.
     *
     * Note that after disabling offline mode, you have to relogin with
     * {@link StartLogin}.
     */
    StartOffline(value: boolean): void;

    /**
     * Restarts the Steam client.
     *
     * @todo I don't remember what the arg is, but IIRC with `true` it disables
     * some ldd check or whatever, really it's only noticeable on slow PCs.
     */
    StartRestart(force: boolean): void;

    /**
     * @todo I don't remember what the arg is, but IIRC with `true` it disables
     * some ldd check or whatever, really it's only noticeable on slow PCs.
     */
    StartShutdown(force: boolean): void;
}

export interface ConnectionAttempt {
    rtCooldownExpiration: number;
}

export interface CurrentUser {
    NotificationCounts: {
        async_game_updates: number;
        comments: number;
        gifts: number;
        help_request_replies: number;
        inventory_items: number;
        invites: number;
        moderator_messages: number;
        offline_messages: number;
        trade_offers: number;
    };
    bHWSurveyPending: boolean;
    bIsLimited: boolean;
    bIsOfflineMode: boolean;
    bPromptToChangePassword: boolean;
    bSupportAckOnlyMessages: boolean;
    bSupportAlertActive: boolean;
    bSupportPopupMessage: boolean;
    clientinstanceid: string;
    strAccountBalance: string;
    strAccountBalancePending: string;
    strAccountName: string;
    strFamilyGroupID: string;
    strSteamID: string;
}

export enum ELoginState {
    None,
    WelcomeDialog,
    WaitingForCreateUser,
    WaitingForCredentials,
    WaitingForNetwork,
    WaitingForServerResponse,
    WaitingForLibraryReady,
    Success,
    Quit,
}

export enum EShutdownStep {
  None,
  Start,
  WaitForGames,
  WaitForCloud,
  FinishingDownload,
  WaitForDownload,
  WaitForServiceApps,
  WaitForLogOff,
  Done,
  // TODO: RegisterForShutdownDone outputs 9 here
}

export enum ESuspendResumeProgressState {
  Invalid,
  Complete,
  CloudSync,
  LoggingIn,
  WaitingForApp,
  Working,
}

export interface LoginUser {
    personaName: string;
    accountName: string;
    hasPin: boolean;
    rememberPassword: boolean;
    avatarUrl: string;
}

export interface ResumeSuspendedGamesResult {
  nAppIDPlayingElsewhere: number;
  result: EResult;
}

export interface SuspendProgress {
  bGameSuspended: boolean;
  state: ESuspendResumeProgressState;
}

export interface SurveyEntry {
    strName: string;
    vecArgs: string[];
}

export interface SurveySection {
    strSectionName: string;
    vecEntries: SurveyEntry[];
}